// $ANTLR 3.2 Sep 23, 2009 12:02:23 F:\\workspace\\ESA\\grammar\\C.g 2009-11-14 17:26:26

package per.chenjw.esa.front;
import java.util.Set;
import java.util.HashSet;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import org.antlr.runtime.debug.*;
import java.io.IOException;

import org.antlr.runtime.tree.*;

public class CParser extends DebugParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "CALL", "ASSIGN", "INDEX", "VARDEF", "CAST", "LOOP_INIT", "LOOP_COND", "LOOP_ITER", "IDENTIFIER", "INC", "DEC", "AND", "OR", "NEG", "BIT_AND", "BIT_OR", "BIT_NEG", "BIT_XOR", "BIT_SHL", "BIT_SHR", "MUL", "DIV", "MOD", "PLUS", "SURPLUS", "HEX_LITERAL", "OCTAL_LITERAL", "DECIMAL_LITERAL", "FLOATING_POINT_LITERAL", "CHARACTER_LITERAL", "STRING_LITERAL", "EscapeSequence", "HexDigit", "IntegerTypeSuffix", "Exponent", "FloatTypeSuffix", "OctalEscape", "UnicodeEscape", "WS", "COMMENT", "LINE_COMMENT", "LINE_COMMAND", "LETTER", "'{'", "'}'", "'typedef'", "';'", "','", "'='", "'('", "')'", "'['", "']'", "'...'", "'extern'", "'static'", "'auto'", "'register'", "'void'", "'signed'", "'unsigned'", "'short'", "'long'", "'char'", "'int'", "'float'", "'double'", "'const'", "'volatile'", "'struct'", "'union'", "':'", "'enum'", "'?'", "'=='", "'!='", "'<'", "'>'", "'<='", "'>='", "'sizeof'", "'.'", "'->'", "'case'", "'default'", "'if'", "'else'", "'switch'", "'while'", "'do'", "'for'", "'goto'", "'continue'", "'break'", "'return'"
    };
    public static final int CAST=8;
    public static final int BIT_NEG=20;
    public static final int FloatTypeSuffix=39;
    public static final int LETTER=46;
    public static final int MOD=26;
    public static final int EOF=-1;
    public static final int LOOP_INIT=9;
    public static final int T__93=93;
    public static final int T__94=94;
    public static final int T__91=91;
    public static final int INC=13;
    public static final int T__92=92;
    public static final int STRING_LITERAL=34;
    public static final int T__90=90;
    public static final int FLOATING_POINT_LITERAL=32;
    public static final int BIT_OR=19;
    public static final int COMMENT=43;
    public static final int VARDEF=7;
    public static final int T__98=98;
    public static final int T__97=97;
    public static final int T__96=96;
    public static final int T__95=95;
    public static final int T__80=80;
    public static final int T__81=81;
    public static final int T__82=82;
    public static final int T__83=83;
    public static final int LINE_COMMENT=44;
    public static final int IntegerTypeSuffix=37;
    public static final int CHARACTER_LITERAL=33;
    public static final int T__85=85;
    public static final int T__84=84;
    public static final int T__87=87;
    public static final int MUL=24;
    public static final int T__86=86;
    public static final int T__89=89;
    public static final int T__88=88;
    public static final int WS=42;
    public static final int T__71=71;
    public static final int T__72=72;
    public static final int T__70=70;
    public static final int LINE_COMMAND=45;
    public static final int OR=16;
    public static final int LOOP_COND=10;
    public static final int SURPLUS=28;
    public static final int CALL=4;
    public static final int T__76=76;
    public static final int T__75=75;
    public static final int T__74=74;
    public static final int T__73=73;
    public static final int DECIMAL_LITERAL=31;
    public static final int EscapeSequence=35;
    public static final int T__79=79;
    public static final int T__78=78;
    public static final int T__77=77;
    public static final int T__68=68;
    public static final int T__69=69;
    public static final int T__66=66;
    public static final int DEC=14;
    public static final int T__67=67;
    public static final int T__64=64;
    public static final int T__65=65;
    public static final int T__62=62;
    public static final int T__63=63;
    public static final int BIT_AND=18;
    public static final int Exponent=38;
    public static final int T__61=61;
    public static final int AND=15;
    public static final int T__60=60;
    public static final int HexDigit=36;
    public static final int T__55=55;
    public static final int T__56=56;
    public static final int INDEX=6;
    public static final int T__57=57;
    public static final int T__58=58;
    public static final int T__51=51;
    public static final int T__52=52;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int IDENTIFIER=12;
    public static final int T__59=59;
    public static final int PLUS=27;
    public static final int HEX_LITERAL=29;
    public static final int T__50=50;
    public static final int LOOP_ITER=11;
    public static final int T__47=47;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int OCTAL_LITERAL=30;
    public static final int BIT_SHL=22;
    public static final int BIT_SHR=23;
    public static final int UnicodeEscape=41;
    public static final int BIT_XOR=21;
    public static final int NEG=17;
    public static final int ASSIGN=5;
    public static final int DIV=25;
    public static final int OctalEscape=40;

    // delegates
    // delegators

    protected static class Scope2_scope {
        //2-level scope: outside, inside function
          Set<String> types;
    }
    protected Stack Scope2_stack = new Stack();

    public static final String[] ruleNames = new String[] {
        "invalidRule", "statement", "struct_declarator", "iteration_statement", 
        "logical_or_expression", "jump_statement", "postfix_expression", 
        "pointer", "struct_declaration_list", "additive_expression", "lvalue", 
        "init_declarator", "function", "synpred6_C", "direct_abstract_declarator", 
        "conditional_expression", "assign_op", "struct_or_union_specifier", 
        "definition", "type_name", "argument_expression_list", "unit", "declarator", 
        "declaration", "synpred1_C", "compound_statement", "unary_expression", 
        "initializer", "synpred7_C", "struct_declarator_list", "cast_expression", 
        "synpred5_C", "storage_class_specifier", "type_qualifier", "relational_expression", 
        "synpred3_C", "logical_and_expression", "expression_statement", 
        "labeled_statement", "init_declarator_list", "expression", "enumerator", 
        "multiplicative_expression", "enumerator_list", "initializer_list", 
        "shift_expression", "prefix_expression", "struct_declaration", "inclusive_or_expression", 
        "enum_specifier", "type_specifier", "and_expression", "unary_operator", 
        "primary_expression", "direct_declarator", "specifiers", "parameter_declaration_list", 
        "parameter_declaration", "type_id", "assignment_expression", "selection_statement", 
        "exclusive_or_expression", "synpred8_C", "equality_expression", 
        "synpred2_C", "statement_list", "abstract_declarator", "synpred4_C", 
        "constant"
    };
     
        public int ruleLevel = 0;
        public int getRuleLevel() { return ruleLevel; }
        public void incRuleLevel() { ruleLevel++; }
        public void decRuleLevel() { ruleLevel--; }
        public CParser(TokenStream input) {
            this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
        }
        public CParser(TokenStream input, int port, RecognizerSharedState state) {
            super(input, state);
            this.state.ruleMemo = new HashMap[68+1];
             
            DebugEventSocketProxy proxy =
                new DebugEventSocketProxy(this,port,adaptor);
            setDebugListener(proxy);
            setTokenStream(new DebugTokenStream(input,proxy));
            try {
                proxy.handshake();
            }
            catch (IOException ioe) {
                reportError(ioe);
            }
            TreeAdaptor adap = new CommonTreeAdaptor();
            setTreeAdaptor(adap);
            proxy.setTreeAdaptor(adap);
        }
    public CParser(TokenStream input, DebugEventListener dbg) {
        super(input, dbg);
        this.state.ruleMemo = new HashMap[68+1];
         
         
        TreeAdaptor adap = new CommonTreeAdaptor();
        setTreeAdaptor(adap);

    }
    protected boolean evalPredicate(boolean result, String predicate) {
        dbg.semanticPredicate(result, predicate);
        return result;
    }

    protected DebugTreeAdaptor adaptor;
    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = new DebugTreeAdaptor(dbg,adaptor);

    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }


    public String[] getTokenNames() { return CParser.tokenNames; }
    public String getGrammarFileName() { return "F:\\workspace\\ESA\\grammar\\C.g"; }


      boolean isTypeName(String name) {
        for (int s=Scope2_stack.size()-1; s>=0; s--) {
          if ( ((Scope2_scope)Scope2_stack.elementAt(s)).types.contains(name) ) {
            //System.out.println(name+" type-defined in "+((Scope2_scope)Scope2_stack.elementAt(s)).);
            return true;
          }
        }
        return false;
      }


    public static class unit_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unit"
    // F:\\workspace\\ESA\\grammar\\C.g:43:1: unit : ( definition )+ ;
    public final CParser.unit_return unit() throws RecognitionException {
    traceIn("unit", 1);
        Scope2_stack.push(new Scope2_scope());

        CParser.unit_return retval = new CParser.unit_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.definition_return definition1 = null;



         // 3 lookup tables
          ((Scope2_scope)Scope2_stack.peek()).types = new HashSet<String>(); // global shared variable/function declaration, typedef

        try { dbg.enterRule(getGrammarFileName(), "unit");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(43, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:47:2: ( ( definition )+ )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:47:4: ( definition )+
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(47,4);
            // F:\\workspace\\ESA\\grammar\\C.g:47:4: ( definition )+
            int cnt1=0;
            try { dbg.enterSubRule(1);

            loop1:
            do {
                int alt1=2;
                try { dbg.enterDecision(1);

                int LA1_0 = input.LA(1);

                if ( (LA1_0==IDENTIFIER||LA1_0==MUL||LA1_0==49||LA1_0==53||(LA1_0>=58 && LA1_0<=74)||LA1_0==76) ) {
                    alt1=1;
                }


                } finally {dbg.exitDecision(1);}

                switch (alt1) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:47:4: definition
            	    {
            	    dbg.location(47,4);
            	    pushFollow(FOLLOW_definition_in_unit120);
            	    definition1=definition();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, definition1.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        dbg.recognitionException(eee);

                        throw eee;
                }
                cnt1++;
            } while (true);
            } finally {dbg.exitSubRule(1);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("unit", 1);
            Scope2_stack.pop();

        }
        dbg.location(48, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "unit");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "unit"

    public static class definition_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "definition"
    // F:\\workspace\\ESA\\grammar\\C.g:49:1: definition : ( ( ( specifiers )? ( pointer )? direct_declarator '{' )=> function | declaration );
    public final CParser.definition_return definition() throws RecognitionException {
    traceIn("definition", 2);
        CParser.definition_return retval = new CParser.definition_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.function_return function2 = null;

        CParser.declaration_return declaration3 = null;



        try { dbg.enterRule(getGrammarFileName(), "definition");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(49, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:50:3: ( ( ( specifiers )? ( pointer )? direct_declarator '{' )=> function | declaration )
            int alt2=2;
            try { dbg.enterDecision(2);

            try {
                isCyclicDecision = true;
                alt2 = dfa2.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(2);}

            switch (alt2) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:50:5: ( ( specifiers )? ( pointer )? direct_declarator '{' )=> function
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(50,54);
                    pushFollow(FOLLOW_function_in_definition148);
                    function2=function();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, function2.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:51:4: declaration
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(51,4);
                    pushFollow(FOLLOW_declaration_in_definition153);
                    declaration3=declaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, declaration3.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("definition", 2);
        }
        dbg.location(52, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "definition");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "definition"

    public static class function_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "function"
    // F:\\workspace\\ESA\\grammar\\C.g:54:1: function : ( specifiers )? declarator '{' ( declaration )* ( statement )* '}' ;
    public final CParser.function_return function() throws RecognitionException {
    traceIn("function", 3);
        Scope2_stack.push(new Scope2_scope());

        CParser.function_return retval = new CParser.function_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal6=null;
        Token char_literal9=null;
        CParser.specifiers_return specifiers4 = null;

        CParser.declarator_return declarator5 = null;

        CParser.declaration_return declaration7 = null;

        CParser.statement_return statement8 = null;


        CommonTree char_literal6_tree=null;
        CommonTree char_literal9_tree=null;

         // 3 lookup tables
          ((Scope2_scope)Scope2_stack.peek()).types = new HashSet<String>(); // global shared variable/function declaration, typedef

        try { dbg.enterRule(getGrammarFileName(), "function");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(54, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:58:2: ( ( specifiers )? declarator '{' ( declaration )* ( statement )* '}' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:58:4: ( specifiers )? declarator '{' ( declaration )* ( statement )* '}'
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(58,4);
            // F:\\workspace\\ESA\\grammar\\C.g:58:4: ( specifiers )?
            int alt3=2;
            try { dbg.enterSubRule(3);
            try { dbg.enterDecision(3);

            try {
                isCyclicDecision = true;
                alt3 = dfa3.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(3);}

            switch (alt3) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:58:4: specifiers
                    {
                    dbg.location(58,4);
                    pushFollow(FOLLOW_specifiers_in_function174);
                    specifiers4=specifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, specifiers4.getTree());

                    }
                    break;

            }
            } finally {dbg.exitSubRule(3);}

            dbg.location(58,16);
            pushFollow(FOLLOW_declarator_in_function177);
            declarator5=declarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, declarator5.getTree());
            dbg.location(58,27);
            char_literal6=(Token)match(input,47,FOLLOW_47_in_function179); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal6_tree = (CommonTree)adaptor.create(char_literal6);
            adaptor.addChild(root_0, char_literal6_tree);
            }
            dbg.location(58,31);
            // F:\\workspace\\ESA\\grammar\\C.g:58:31: ( declaration )*
            try { dbg.enterSubRule(4);

            loop4:
            do {
                int alt4=2;
                try { dbg.enterDecision(4);

                try {
                    isCyclicDecision = true;
                    alt4 = dfa4.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(4);}

                switch (alt4) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:58:31: declaration
            	    {
            	    dbg.location(58,31);
            	    pushFollow(FOLLOW_declaration_in_function181);
            	    declaration7=declaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, declaration7.getTree());

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);
            } finally {dbg.exitSubRule(4);}

            dbg.location(58,44);
            // F:\\workspace\\ESA\\grammar\\C.g:58:44: ( statement )*
            try { dbg.enterSubRule(5);

            loop5:
            do {
                int alt5=2;
                try { dbg.enterDecision(5);

                int LA5_0 = input.LA(1);

                if ( ((LA5_0>=IDENTIFIER && LA5_0<=DEC)||(LA5_0>=NEG && LA5_0<=BIT_AND)||LA5_0==BIT_NEG||LA5_0==MUL||(LA5_0>=PLUS && LA5_0<=STRING_LITERAL)||LA5_0==47||LA5_0==50||LA5_0==53||LA5_0==84||(LA5_0>=87 && LA5_0<=89)||(LA5_0>=91 && LA5_0<=98)) ) {
                    alt5=1;
                }


                } finally {dbg.exitDecision(5);}

                switch (alt5) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:58:44: statement
            	    {
            	    dbg.location(58,44);
            	    pushFollow(FOLLOW_statement_in_function184);
            	    statement8=statement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement8.getTree());

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);
            } finally {dbg.exitSubRule(5);}

            dbg.location(58,55);
            char_literal9=(Token)match(input,48,FOLLOW_48_in_function187); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal9_tree = (CommonTree)adaptor.create(char_literal9);
            adaptor.addChild(root_0, char_literal9_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("function", 3);
            Scope2_stack.pop();

        }
        dbg.location(59, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "function");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "function"

    protected static class declaration_scope {
        boolean isTypedef;
    }
    protected Stack declaration_stack = new Stack();

    public static class declaration_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "declaration"
    // F:\\workspace\\ESA\\grammar\\C.g:61:1: declaration : ( 'typedef' specifiers init_declarator_list ';' | specifiers ( init_declarator_list )? ';' );
    public final CParser.declaration_return declaration() throws RecognitionException {
    traceIn("declaration", 4);
        declaration_stack.push(new declaration_scope());
        CParser.declaration_return retval = new CParser.declaration_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal10=null;
        Token char_literal13=null;
        Token char_literal16=null;
        CParser.specifiers_return specifiers11 = null;

        CParser.init_declarator_list_return init_declarator_list12 = null;

        CParser.specifiers_return specifiers14 = null;

        CParser.init_declarator_list_return init_declarator_list15 = null;


        CommonTree string_literal10_tree=null;
        CommonTree char_literal13_tree=null;
        CommonTree char_literal16_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "declaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(61, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:63:2: ( 'typedef' specifiers init_declarator_list ';' | specifiers ( init_declarator_list )? ';' )
            int alt7=2;
            try { dbg.enterDecision(7);

            int LA7_0 = input.LA(1);

            if ( (LA7_0==49) ) {
                alt7=1;
            }
            else if ( (LA7_0==IDENTIFIER||(LA7_0>=58 && LA7_0<=74)||LA7_0==76) ) {
                alt7=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(7);}

            switch (alt7) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:63:4: 'typedef' specifiers init_declarator_list ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(63,4);
                    string_literal10=(Token)match(input,49,FOLLOW_49_in_declaration207); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal10_tree = (CommonTree)adaptor.create(string_literal10);
                    adaptor.addChild(root_0, string_literal10_tree);
                    }
                    dbg.location(63,14);
                    pushFollow(FOLLOW_specifiers_in_declaration209);
                    specifiers11=specifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, specifiers11.getTree());
                    dbg.location(63,25);
                    if ( state.backtracking==0 ) {
                      ((declaration_scope)declaration_stack.peek()).isTypedef =true;
                    }
                    dbg.location(63,56);
                    pushFollow(FOLLOW_init_declarator_list_in_declaration212);
                    init_declarator_list12=init_declarator_list();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, init_declarator_list12.getTree());
                    dbg.location(63,77);
                    char_literal13=(Token)match(input,50,FOLLOW_50_in_declaration214); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal13_tree = (CommonTree)adaptor.create(char_literal13);
                    adaptor.addChild(root_0, char_literal13_tree);
                    }

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:64:4: specifiers ( init_declarator_list )? ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(64,4);
                    pushFollow(FOLLOW_specifiers_in_declaration220);
                    specifiers14=specifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, specifiers14.getTree());
                    dbg.location(64,15);
                    // F:\\workspace\\ESA\\grammar\\C.g:64:15: ( init_declarator_list )?
                    int alt6=2;
                    try { dbg.enterSubRule(6);
                    try { dbg.enterDecision(6);

                    int LA6_0 = input.LA(1);

                    if ( (LA6_0==IDENTIFIER||LA6_0==MUL||LA6_0==53) ) {
                        alt6=1;
                    }
                    } finally {dbg.exitDecision(6);}

                    switch (alt6) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:64:15: init_declarator_list
                            {
                            dbg.location(64,15);
                            pushFollow(FOLLOW_init_declarator_list_in_declaration222);
                            init_declarator_list15=init_declarator_list();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, init_declarator_list15.getTree());

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(6);}

                    dbg.location(64,37);
                    char_literal16=(Token)match(input,50,FOLLOW_50_in_declaration225); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal16_tree = (CommonTree)adaptor.create(char_literal16);
                    adaptor.addChild(root_0, char_literal16_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("declaration", 4);
            declaration_stack.pop();
        }
        dbg.location(65, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "declaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "declaration"

    public static class init_declarator_list_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "init_declarator_list"
    // F:\\workspace\\ESA\\grammar\\C.g:66:1: init_declarator_list : init_declarator ( ',' init_declarator )* ;
    public final CParser.init_declarator_list_return init_declarator_list() throws RecognitionException {
    traceIn("init_declarator_list", 5);
        CParser.init_declarator_list_return retval = new CParser.init_declarator_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal18=null;
        CParser.init_declarator_return init_declarator17 = null;

        CParser.init_declarator_return init_declarator19 = null;


        CommonTree char_literal18_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "init_declarator_list");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(66, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:67:2: ( init_declarator ( ',' init_declarator )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:67:4: init_declarator ( ',' init_declarator )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(67,4);
            pushFollow(FOLLOW_init_declarator_in_init_declarator_list235);
            init_declarator17=init_declarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, init_declarator17.getTree());
            dbg.location(67,20);
            // F:\\workspace\\ESA\\grammar\\C.g:67:20: ( ',' init_declarator )*
            try { dbg.enterSubRule(8);

            loop8:
            do {
                int alt8=2;
                try { dbg.enterDecision(8);

                int LA8_0 = input.LA(1);

                if ( (LA8_0==51) ) {
                    alt8=1;
                }


                } finally {dbg.exitDecision(8);}

                switch (alt8) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:67:21: ',' init_declarator
            	    {
            	    dbg.location(67,21);
            	    char_literal18=(Token)match(input,51,FOLLOW_51_in_init_declarator_list238); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal18_tree = (CommonTree)adaptor.create(char_literal18);
            	    adaptor.addChild(root_0, char_literal18_tree);
            	    }
            	    dbg.location(67,25);
            	    pushFollow(FOLLOW_init_declarator_in_init_declarator_list240);
            	    init_declarator19=init_declarator();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, init_declarator19.getTree());

            	    }
            	    break;

            	default :
            	    break loop8;
                }
            } while (true);
            } finally {dbg.exitSubRule(8);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("init_declarator_list", 5);
        }
        dbg.location(68, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "init_declarator_list");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "init_declarator_list"

    public static class init_declarator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "init_declarator"
    // F:\\workspace\\ESA\\grammar\\C.g:69:1: init_declarator : declarator ( '=' initializer )? ;
    public final CParser.init_declarator_return init_declarator() throws RecognitionException {
    traceIn("init_declarator", 6);
        CParser.init_declarator_return retval = new CParser.init_declarator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal21=null;
        CParser.declarator_return declarator20 = null;

        CParser.initializer_return initializer22 = null;


        CommonTree char_literal21_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "init_declarator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(69, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:70:2: ( declarator ( '=' initializer )? )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:70:4: declarator ( '=' initializer )?
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(70,4);
            pushFollow(FOLLOW_declarator_in_init_declarator252);
            declarator20=declarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, declarator20.getTree());
            dbg.location(70,15);
            // F:\\workspace\\ESA\\grammar\\C.g:70:15: ( '=' initializer )?
            int alt9=2;
            try { dbg.enterSubRule(9);
            try { dbg.enterDecision(9);

            int LA9_0 = input.LA(1);

            if ( (LA9_0==52) ) {
                alt9=1;
            }
            } finally {dbg.exitDecision(9);}

            switch (alt9) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:70:16: '=' initializer
                    {
                    dbg.location(70,16);
                    char_literal21=(Token)match(input,52,FOLLOW_52_in_init_declarator255); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal21_tree = (CommonTree)adaptor.create(char_literal21);
                    adaptor.addChild(root_0, char_literal21_tree);
                    }
                    dbg.location(70,20);
                    pushFollow(FOLLOW_initializer_in_init_declarator257);
                    initializer22=initializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, initializer22.getTree());

                    }
                    break;

            }
            } finally {dbg.exitSubRule(9);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("init_declarator", 6);
        }
        dbg.location(71, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "init_declarator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "init_declarator"

    public static class declarator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "declarator"
    // F:\\workspace\\ESA\\grammar\\C.g:72:1: declarator : ( pointer )? direct_declarator ;
    public final CParser.declarator_return declarator() throws RecognitionException {
    traceIn("declarator", 7);
        CParser.declarator_return retval = new CParser.declarator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.pointer_return pointer23 = null;

        CParser.direct_declarator_return direct_declarator24 = null;



        try { dbg.enterRule(getGrammarFileName(), "declarator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(72, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:73:2: ( ( pointer )? direct_declarator )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:73:4: ( pointer )? direct_declarator
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(73,4);
            // F:\\workspace\\ESA\\grammar\\C.g:73:4: ( pointer )?
            int alt10=2;
            try { dbg.enterSubRule(10);
            try { dbg.enterDecision(10);

            int LA10_0 = input.LA(1);

            if ( (LA10_0==MUL) ) {
                alt10=1;
            }
            } finally {dbg.exitDecision(10);}

            switch (alt10) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:73:4: pointer
                    {
                    dbg.location(73,4);
                    pushFollow(FOLLOW_pointer_in_declarator269);
                    pointer23=pointer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, pointer23.getTree());

                    }
                    break;

            }
            } finally {dbg.exitSubRule(10);}

            dbg.location(73,13);
            pushFollow(FOLLOW_direct_declarator_in_declarator272);
            direct_declarator24=direct_declarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, direct_declarator24.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("declarator", 7);
        }
        dbg.location(74, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "declarator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "declarator"

    public static class pointer_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "pointer"
    // F:\\workspace\\ESA\\grammar\\C.g:75:1: pointer : ( '*' ( type_qualifier )? )+ ;
    public final CParser.pointer_return pointer() throws RecognitionException {
    traceIn("pointer", 8);
        CParser.pointer_return retval = new CParser.pointer_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal25=null;
        CParser.type_qualifier_return type_qualifier26 = null;


        CommonTree char_literal25_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "pointer");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(75, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:76:2: ( ( '*' ( type_qualifier )? )+ )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:76:4: ( '*' ( type_qualifier )? )+
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(76,4);
            // F:\\workspace\\ESA\\grammar\\C.g:76:4: ( '*' ( type_qualifier )? )+
            int cnt12=0;
            try { dbg.enterSubRule(12);

            loop12:
            do {
                int alt12=2;
                try { dbg.enterDecision(12);

                int LA12_0 = input.LA(1);

                if ( (LA12_0==MUL) ) {
                    alt12=1;
                }


                } finally {dbg.exitDecision(12);}

                switch (alt12) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:76:5: '*' ( type_qualifier )?
            	    {
            	    dbg.location(76,5);
            	    char_literal25=(Token)match(input,MUL,FOLLOW_MUL_in_pointer283); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal25_tree = (CommonTree)adaptor.create(char_literal25);
            	    adaptor.addChild(root_0, char_literal25_tree);
            	    }
            	    dbg.location(76,9);
            	    // F:\\workspace\\ESA\\grammar\\C.g:76:9: ( type_qualifier )?
            	    int alt11=2;
            	    try { dbg.enterSubRule(11);
            	    try { dbg.enterDecision(11);

            	    int LA11_0 = input.LA(1);

            	    if ( ((LA11_0>=71 && LA11_0<=72)) ) {
            	        alt11=1;
            	    }
            	    } finally {dbg.exitDecision(11);}

            	    switch (alt11) {
            	        case 1 :
            	            dbg.enterAlt(1);

            	            // F:\\workspace\\ESA\\grammar\\C.g:76:9: type_qualifier
            	            {
            	            dbg.location(76,9);
            	            pushFollow(FOLLOW_type_qualifier_in_pointer285);
            	            type_qualifier26=type_qualifier();

            	            state._fsp--;
            	            if (state.failed) return retval;
            	            if ( state.backtracking==0 ) adaptor.addChild(root_0, type_qualifier26.getTree());

            	            }
            	            break;

            	    }
            	    } finally {dbg.exitSubRule(11);}


            	    }
            	    break;

            	default :
            	    if ( cnt12 >= 1 ) break loop12;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(12, input);
                        dbg.recognitionException(eee);

                        throw eee;
                }
                cnt12++;
            } while (true);
            } finally {dbg.exitSubRule(12);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("pointer", 8);
        }
        dbg.location(77, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "pointer");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "pointer"

    public static class direct_declarator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "direct_declarator"
    // F:\\workspace\\ESA\\grammar\\C.g:78:1: direct_declarator : ( IDENTIFIER | '(' declarator ')' ) ( | ( '[' ( expression )? ']' )+ | ( '(' ( parameter_declaration_list )? ')' )+ ) ;
    public final CParser.direct_declarator_return direct_declarator() throws RecognitionException {
    traceIn("direct_declarator", 9);
        CParser.direct_declarator_return retval = new CParser.direct_declarator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENTIFIER27=null;
        Token char_literal28=null;
        Token char_literal30=null;
        Token char_literal31=null;
        Token char_literal33=null;
        Token char_literal34=null;
        Token char_literal36=null;
        CParser.declarator_return declarator29 = null;

        CParser.expression_return expression32 = null;

        CParser.parameter_declaration_list_return parameter_declaration_list35 = null;


        CommonTree IDENTIFIER27_tree=null;
        CommonTree char_literal28_tree=null;
        CommonTree char_literal30_tree=null;
        CommonTree char_literal31_tree=null;
        CommonTree char_literal33_tree=null;
        CommonTree char_literal34_tree=null;
        CommonTree char_literal36_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "direct_declarator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(78, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:79:2: ( ( IDENTIFIER | '(' declarator ')' ) ( | ( '[' ( expression )? ']' )+ | ( '(' ( parameter_declaration_list )? ')' )+ ) )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:79:4: ( IDENTIFIER | '(' declarator ')' ) ( | ( '[' ( expression )? ']' )+ | ( '(' ( parameter_declaration_list )? ')' )+ )
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(79,4);
            // F:\\workspace\\ESA\\grammar\\C.g:79:4: ( IDENTIFIER | '(' declarator ')' )
            int alt13=2;
            try { dbg.enterSubRule(13);
            try { dbg.enterDecision(13);

            int LA13_0 = input.LA(1);

            if ( (LA13_0==IDENTIFIER) ) {
                alt13=1;
            }
            else if ( (LA13_0==53) ) {
                alt13=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(13);}

            switch (alt13) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:79:5: IDENTIFIER
                    {
                    dbg.location(79,5);
                    IDENTIFIER27=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_direct_declarator299); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER27_tree = (CommonTree)adaptor.create(IDENTIFIER27);
                    adaptor.addChild(root_0, IDENTIFIER27_tree);
                    }
                    dbg.location(79,16);
                    if ( state.backtracking==0 ) {
                      if (declaration_stack.size()>0 && ((declaration_scope)declaration_stack.peek()).isTypedef) {
                              ((Scope2_scope)Scope2_stack.peek()).types.add((IDENTIFIER27!=null?IDENTIFIER27.getText():null));    }
                    }

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:81:5: '(' declarator ')'
                    {
                    dbg.location(81,5);
                    char_literal28=(Token)match(input,53,FOLLOW_53_in_direct_declarator307); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal28_tree = (CommonTree)adaptor.create(char_literal28);
                    adaptor.addChild(root_0, char_literal28_tree);
                    }
                    dbg.location(81,9);
                    pushFollow(FOLLOW_declarator_in_direct_declarator309);
                    declarator29=declarator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, declarator29.getTree());
                    dbg.location(81,20);
                    char_literal30=(Token)match(input,54,FOLLOW_54_in_direct_declarator311); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal30_tree = (CommonTree)adaptor.create(char_literal30);
                    adaptor.addChild(root_0, char_literal30_tree);
                    }

                    }
                    break;

            }
            } finally {dbg.exitSubRule(13);}

            dbg.location(83,4);
            // F:\\workspace\\ESA\\grammar\\C.g:83:4: ( | ( '[' ( expression )? ']' )+ | ( '(' ( parameter_declaration_list )? ')' )+ )
            int alt18=3;
            try { dbg.enterSubRule(18);
            try { dbg.enterDecision(18);

            switch ( input.LA(1) ) {
            case 47:
            case 50:
            case 51:
            case 52:
            case 54:
            case 75:
                {
                alt18=1;
                }
                break;
            case 55:
                {
                alt18=2;
                }
                break;
            case 53:
                {
                alt18=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(18);}

            switch (alt18) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:84:4: 
                    {
                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:84:6: ( '[' ( expression )? ']' )+
                    {
                    dbg.location(84,6);
                    // F:\\workspace\\ESA\\grammar\\C.g:84:6: ( '[' ( expression )? ']' )+
                    int cnt15=0;
                    try { dbg.enterSubRule(15);

                    loop15:
                    do {
                        int alt15=2;
                        try { dbg.enterDecision(15);

                        int LA15_0 = input.LA(1);

                        if ( (LA15_0==55) ) {
                            alt15=1;
                        }


                        } finally {dbg.exitDecision(15);}

                        switch (alt15) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // F:\\workspace\\ESA\\grammar\\C.g:84:7: '[' ( expression )? ']'
                    	    {
                    	    dbg.location(84,7);
                    	    char_literal31=(Token)match(input,55,FOLLOW_55_in_direct_declarator329); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal31_tree = (CommonTree)adaptor.create(char_literal31);
                    	    adaptor.addChild(root_0, char_literal31_tree);
                    	    }
                    	    dbg.location(84,11);
                    	    // F:\\workspace\\ESA\\grammar\\C.g:84:11: ( expression )?
                    	    int alt14=2;
                    	    try { dbg.enterSubRule(14);
                    	    try { dbg.enterDecision(14);

                    	    int LA14_0 = input.LA(1);

                    	    if ( ((LA14_0>=IDENTIFIER && LA14_0<=DEC)||(LA14_0>=NEG && LA14_0<=BIT_AND)||LA14_0==BIT_NEG||LA14_0==MUL||(LA14_0>=PLUS && LA14_0<=STRING_LITERAL)||LA14_0==53||LA14_0==84) ) {
                    	        alt14=1;
                    	    }
                    	    } finally {dbg.exitDecision(14);}

                    	    switch (alt14) {
                    	        case 1 :
                    	            dbg.enterAlt(1);

                    	            // F:\\workspace\\ESA\\grammar\\C.g:84:11: expression
                    	            {
                    	            dbg.location(84,11);
                    	            pushFollow(FOLLOW_expression_in_direct_declarator331);
                    	            expression32=expression();

                    	            state._fsp--;
                    	            if (state.failed) return retval;
                    	            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression32.getTree());

                    	            }
                    	            break;

                    	    }
                    	    } finally {dbg.exitSubRule(14);}

                    	    dbg.location(84,23);
                    	    char_literal33=(Token)match(input,56,FOLLOW_56_in_direct_declarator334); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal33_tree = (CommonTree)adaptor.create(char_literal33);
                    	    adaptor.addChild(root_0, char_literal33_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt15 >= 1 ) break loop15;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(15, input);
                                dbg.recognitionException(eee);

                                throw eee;
                        }
                        cnt15++;
                    } while (true);
                    } finally {dbg.exitSubRule(15);}


                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:85:6: ( '(' ( parameter_declaration_list )? ')' )+
                    {
                    dbg.location(85,6);
                    // F:\\workspace\\ESA\\grammar\\C.g:85:6: ( '(' ( parameter_declaration_list )? ')' )+
                    int cnt17=0;
                    try { dbg.enterSubRule(17);

                    loop17:
                    do {
                        int alt17=2;
                        try { dbg.enterDecision(17);

                        int LA17_0 = input.LA(1);

                        if ( (LA17_0==53) ) {
                            alt17=1;
                        }


                        } finally {dbg.exitDecision(17);}

                        switch (alt17) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // F:\\workspace\\ESA\\grammar\\C.g:85:7: '(' ( parameter_declaration_list )? ')'
                    	    {
                    	    dbg.location(85,7);
                    	    char_literal34=(Token)match(input,53,FOLLOW_53_in_direct_declarator346); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal34_tree = (CommonTree)adaptor.create(char_literal34);
                    	    adaptor.addChild(root_0, char_literal34_tree);
                    	    }
                    	    dbg.location(85,11);
                    	    // F:\\workspace\\ESA\\grammar\\C.g:85:11: ( parameter_declaration_list )?
                    	    int alt16=2;
                    	    try { dbg.enterSubRule(16);
                    	    try { dbg.enterDecision(16);

                    	    int LA16_0 = input.LA(1);

                    	    if ( (LA16_0==IDENTIFIER||(LA16_0>=58 && LA16_0<=74)||LA16_0==76) ) {
                    	        alt16=1;
                    	    }
                    	    } finally {dbg.exitDecision(16);}

                    	    switch (alt16) {
                    	        case 1 :
                    	            dbg.enterAlt(1);

                    	            // F:\\workspace\\ESA\\grammar\\C.g:85:11: parameter_declaration_list
                    	            {
                    	            dbg.location(85,11);
                    	            pushFollow(FOLLOW_parameter_declaration_list_in_direct_declarator348);
                    	            parameter_declaration_list35=parameter_declaration_list();

                    	            state._fsp--;
                    	            if (state.failed) return retval;
                    	            if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_declaration_list35.getTree());

                    	            }
                    	            break;

                    	    }
                    	    } finally {dbg.exitSubRule(16);}

                    	    dbg.location(85,39);
                    	    char_literal36=(Token)match(input,54,FOLLOW_54_in_direct_declarator351); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal36_tree = (CommonTree)adaptor.create(char_literal36);
                    	    adaptor.addChild(root_0, char_literal36_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt17 >= 1 ) break loop17;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(17, input);
                                dbg.recognitionException(eee);

                                throw eee;
                        }
                        cnt17++;
                    } while (true);
                    } finally {dbg.exitSubRule(17);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(18);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("direct_declarator", 9);
        }
        dbg.location(87, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "direct_declarator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "direct_declarator"

    public static class parameter_declaration_list_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameter_declaration_list"
    // F:\\workspace\\ESA\\grammar\\C.g:88:1: parameter_declaration_list : parameter_declaration ( ',' parameter_declaration )* ( ',' '...' )? ;
    public final CParser.parameter_declaration_list_return parameter_declaration_list() throws RecognitionException {
    traceIn("parameter_declaration_list", 10);
        CParser.parameter_declaration_list_return retval = new CParser.parameter_declaration_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal38=null;
        Token char_literal40=null;
        Token string_literal41=null;
        CParser.parameter_declaration_return parameter_declaration37 = null;

        CParser.parameter_declaration_return parameter_declaration39 = null;


        CommonTree char_literal38_tree=null;
        CommonTree char_literal40_tree=null;
        CommonTree string_literal41_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "parameter_declaration_list");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(88, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:89:2: ( parameter_declaration ( ',' parameter_declaration )* ( ',' '...' )? )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:89:4: parameter_declaration ( ',' parameter_declaration )* ( ',' '...' )?
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(89,4);
            pushFollow(FOLLOW_parameter_declaration_in_parameter_declaration_list369);
            parameter_declaration37=parameter_declaration();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_declaration37.getTree());
            dbg.location(89,26);
            // F:\\workspace\\ESA\\grammar\\C.g:89:26: ( ',' parameter_declaration )*
            try { dbg.enterSubRule(19);

            loop19:
            do {
                int alt19=2;
                try { dbg.enterDecision(19);

                int LA19_0 = input.LA(1);

                if ( (LA19_0==51) ) {
                    int LA19_1 = input.LA(2);

                    if ( (LA19_1==IDENTIFIER||(LA19_1>=58 && LA19_1<=74)||LA19_1==76) ) {
                        alt19=1;
                    }


                }


                } finally {dbg.exitDecision(19);}

                switch (alt19) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:89:27: ',' parameter_declaration
            	    {
            	    dbg.location(89,27);
            	    char_literal38=(Token)match(input,51,FOLLOW_51_in_parameter_declaration_list372); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal38_tree = (CommonTree)adaptor.create(char_literal38);
            	    adaptor.addChild(root_0, char_literal38_tree);
            	    }
            	    dbg.location(89,31);
            	    pushFollow(FOLLOW_parameter_declaration_in_parameter_declaration_list374);
            	    parameter_declaration39=parameter_declaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_declaration39.getTree());

            	    }
            	    break;

            	default :
            	    break loop19;
                }
            } while (true);
            } finally {dbg.exitSubRule(19);}

            dbg.location(89,55);
            // F:\\workspace\\ESA\\grammar\\C.g:89:55: ( ',' '...' )?
            int alt20=2;
            try { dbg.enterSubRule(20);
            try { dbg.enterDecision(20);

            int LA20_0 = input.LA(1);

            if ( (LA20_0==51) ) {
                alt20=1;
            }
            } finally {dbg.exitDecision(20);}

            switch (alt20) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:89:56: ',' '...'
                    {
                    dbg.location(89,56);
                    char_literal40=(Token)match(input,51,FOLLOW_51_in_parameter_declaration_list379); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal40_tree = (CommonTree)adaptor.create(char_literal40);
                    adaptor.addChild(root_0, char_literal40_tree);
                    }
                    dbg.location(89,60);
                    string_literal41=(Token)match(input,57,FOLLOW_57_in_parameter_declaration_list381); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal41_tree = (CommonTree)adaptor.create(string_literal41);
                    adaptor.addChild(root_0, string_literal41_tree);
                    }

                    }
                    break;

            }
            } finally {dbg.exitSubRule(20);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("parameter_declaration_list", 10);
        }
        dbg.location(90, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "parameter_declaration_list");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "parameter_declaration_list"

    public static class parameter_declaration_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameter_declaration"
    // F:\\workspace\\ESA\\grammar\\C.g:91:1: parameter_declaration : specifiers ( declarator )? ;
    public final CParser.parameter_declaration_return parameter_declaration() throws RecognitionException {
    traceIn("parameter_declaration", 11);
        CParser.parameter_declaration_return retval = new CParser.parameter_declaration_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.specifiers_return specifiers42 = null;

        CParser.declarator_return declarator43 = null;



        try { dbg.enterRule(getGrammarFileName(), "parameter_declaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(91, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:92:2: ( specifiers ( declarator )? )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:92:4: specifiers ( declarator )?
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(92,4);
            pushFollow(FOLLOW_specifiers_in_parameter_declaration393);
            specifiers42=specifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, specifiers42.getTree());
            dbg.location(92,15);
            // F:\\workspace\\ESA\\grammar\\C.g:92:15: ( declarator )?
            int alt21=2;
            try { dbg.enterSubRule(21);
            try { dbg.enterDecision(21);

            int LA21_0 = input.LA(1);

            if ( (LA21_0==IDENTIFIER||LA21_0==MUL||LA21_0==53) ) {
                alt21=1;
            }
            } finally {dbg.exitDecision(21);}

            switch (alt21) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:92:16: declarator
                    {
                    dbg.location(92,16);
                    pushFollow(FOLLOW_declarator_in_parameter_declaration396);
                    declarator43=declarator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, declarator43.getTree());

                    }
                    break;

            }
            } finally {dbg.exitSubRule(21);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("parameter_declaration", 11);
        }
        dbg.location(93, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "parameter_declaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "parameter_declaration"

    public static class type_name_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "type_name"
    // F:\\workspace\\ESA\\grammar\\C.g:95:1: type_name : specifiers ( abstract_declarator )? ;
    public final CParser.type_name_return type_name() throws RecognitionException {
    traceIn("type_name", 12);
        CParser.type_name_return retval = new CParser.type_name_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.specifiers_return specifiers44 = null;

        CParser.abstract_declarator_return abstract_declarator45 = null;



        try { dbg.enterRule(getGrammarFileName(), "type_name");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(95, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:96:2: ( specifiers ( abstract_declarator )? )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:96:4: specifiers ( abstract_declarator )?
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(96,4);
            pushFollow(FOLLOW_specifiers_in_type_name409);
            specifiers44=specifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, specifiers44.getTree());
            dbg.location(96,15);
            // F:\\workspace\\ESA\\grammar\\C.g:96:15: ( abstract_declarator )?
            int alt22=2;
            try { dbg.enterSubRule(22);
            try { dbg.enterDecision(22);

            int LA22_0 = input.LA(1);

            if ( (LA22_0==MUL||LA22_0==53) ) {
                alt22=1;
            }
            } finally {dbg.exitDecision(22);}

            switch (alt22) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:96:15: abstract_declarator
                    {
                    dbg.location(96,15);
                    pushFollow(FOLLOW_abstract_declarator_in_type_name411);
                    abstract_declarator45=abstract_declarator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, abstract_declarator45.getTree());

                    }
                    break;

            }
            } finally {dbg.exitSubRule(22);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("type_name", 12);
        }
        dbg.location(97, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "type_name");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "type_name"

    public static class abstract_declarator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "abstract_declarator"
    // F:\\workspace\\ESA\\grammar\\C.g:98:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator );
    public final CParser.abstract_declarator_return abstract_declarator() throws RecognitionException {
    traceIn("abstract_declarator", 13);
        CParser.abstract_declarator_return retval = new CParser.abstract_declarator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.pointer_return pointer46 = null;

        CParser.direct_abstract_declarator_return direct_abstract_declarator47 = null;

        CParser.direct_abstract_declarator_return direct_abstract_declarator48 = null;



        try { dbg.enterRule(getGrammarFileName(), "abstract_declarator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(98, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:99:2: ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator )
            int alt24=2;
            try { dbg.enterDecision(24);

            int LA24_0 = input.LA(1);

            if ( (LA24_0==MUL) ) {
                alt24=1;
            }
            else if ( (LA24_0==53) ) {
                alt24=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 24, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(24);}

            switch (alt24) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:99:4: pointer ( direct_abstract_declarator )?
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(99,4);
                    pushFollow(FOLLOW_pointer_in_abstract_declarator422);
                    pointer46=pointer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, pointer46.getTree());
                    dbg.location(99,12);
                    // F:\\workspace\\ESA\\grammar\\C.g:99:12: ( direct_abstract_declarator )?
                    int alt23=2;
                    try { dbg.enterSubRule(23);
                    try { dbg.enterDecision(23);

                    int LA23_0 = input.LA(1);

                    if ( (LA23_0==53) ) {
                        alt23=1;
                    }
                    } finally {dbg.exitDecision(23);}

                    switch (alt23) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:99:12: direct_abstract_declarator
                            {
                            dbg.location(99,12);
                            pushFollow(FOLLOW_direct_abstract_declarator_in_abstract_declarator424);
                            direct_abstract_declarator47=direct_abstract_declarator();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, direct_abstract_declarator47.getTree());

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(23);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:100:4: direct_abstract_declarator
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(100,4);
                    pushFollow(FOLLOW_direct_abstract_declarator_in_abstract_declarator430);
                    direct_abstract_declarator48=direct_abstract_declarator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, direct_abstract_declarator48.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("abstract_declarator", 13);
        }
        dbg.location(101, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "abstract_declarator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "abstract_declarator"

    public static class direct_abstract_declarator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "direct_abstract_declarator"
    // F:\\workspace\\ESA\\grammar\\C.g:102:1: direct_abstract_declarator : '(' abstract_declarator ')' ( | ( '[' ( expression )? ']' )+ | ( '(' ( parameter_declaration_list )? ')' )+ ) ;
    public final CParser.direct_abstract_declarator_return direct_abstract_declarator() throws RecognitionException {
    traceIn("direct_abstract_declarator", 14);
        CParser.direct_abstract_declarator_return retval = new CParser.direct_abstract_declarator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal49=null;
        Token char_literal51=null;
        Token char_literal52=null;
        Token char_literal54=null;
        Token char_literal55=null;
        Token char_literal57=null;
        CParser.abstract_declarator_return abstract_declarator50 = null;

        CParser.expression_return expression53 = null;

        CParser.parameter_declaration_list_return parameter_declaration_list56 = null;


        CommonTree char_literal49_tree=null;
        CommonTree char_literal51_tree=null;
        CommonTree char_literal52_tree=null;
        CommonTree char_literal54_tree=null;
        CommonTree char_literal55_tree=null;
        CommonTree char_literal57_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "direct_abstract_declarator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(102, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:103:2: ( '(' abstract_declarator ')' ( | ( '[' ( expression )? ']' )+ | ( '(' ( parameter_declaration_list )? ')' )+ ) )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:103:4: '(' abstract_declarator ')' ( | ( '[' ( expression )? ']' )+ | ( '(' ( parameter_declaration_list )? ')' )+ )
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(103,4);
            char_literal49=(Token)match(input,53,FOLLOW_53_in_direct_abstract_declarator440); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal49_tree = (CommonTree)adaptor.create(char_literal49);
            adaptor.addChild(root_0, char_literal49_tree);
            }
            dbg.location(103,8);
            pushFollow(FOLLOW_abstract_declarator_in_direct_abstract_declarator442);
            abstract_declarator50=abstract_declarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, abstract_declarator50.getTree());
            dbg.location(103,28);
            char_literal51=(Token)match(input,54,FOLLOW_54_in_direct_abstract_declarator444); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal51_tree = (CommonTree)adaptor.create(char_literal51);
            adaptor.addChild(root_0, char_literal51_tree);
            }
            dbg.location(104,3);
            // F:\\workspace\\ESA\\grammar\\C.g:104:3: ( | ( '[' ( expression )? ']' )+ | ( '(' ( parameter_declaration_list )? ')' )+ )
            int alt29=3;
            try { dbg.enterSubRule(29);
            try { dbg.enterDecision(29);

            switch ( input.LA(1) ) {
            case 54:
                {
                alt29=1;
                }
                break;
            case 55:
                {
                alt29=2;
                }
                break;
            case 53:
                {
                alt29=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 29, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(29);}

            switch (alt29) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:105:3: 
                    {
                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:105:5: ( '[' ( expression )? ']' )+
                    {
                    dbg.location(105,5);
                    // F:\\workspace\\ESA\\grammar\\C.g:105:5: ( '[' ( expression )? ']' )+
                    int cnt26=0;
                    try { dbg.enterSubRule(26);

                    loop26:
                    do {
                        int alt26=2;
                        try { dbg.enterDecision(26);

                        int LA26_0 = input.LA(1);

                        if ( (LA26_0==55) ) {
                            alt26=1;
                        }


                        } finally {dbg.exitDecision(26);}

                        switch (alt26) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // F:\\workspace\\ESA\\grammar\\C.g:105:6: '[' ( expression )? ']'
                    	    {
                    	    dbg.location(105,6);
                    	    char_literal52=(Token)match(input,55,FOLLOW_55_in_direct_abstract_declarator456); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal52_tree = (CommonTree)adaptor.create(char_literal52);
                    	    adaptor.addChild(root_0, char_literal52_tree);
                    	    }
                    	    dbg.location(105,10);
                    	    // F:\\workspace\\ESA\\grammar\\C.g:105:10: ( expression )?
                    	    int alt25=2;
                    	    try { dbg.enterSubRule(25);
                    	    try { dbg.enterDecision(25);

                    	    int LA25_0 = input.LA(1);

                    	    if ( ((LA25_0>=IDENTIFIER && LA25_0<=DEC)||(LA25_0>=NEG && LA25_0<=BIT_AND)||LA25_0==BIT_NEG||LA25_0==MUL||(LA25_0>=PLUS && LA25_0<=STRING_LITERAL)||LA25_0==53||LA25_0==84) ) {
                    	        alt25=1;
                    	    }
                    	    } finally {dbg.exitDecision(25);}

                    	    switch (alt25) {
                    	        case 1 :
                    	            dbg.enterAlt(1);

                    	            // F:\\workspace\\ESA\\grammar\\C.g:105:10: expression
                    	            {
                    	            dbg.location(105,10);
                    	            pushFollow(FOLLOW_expression_in_direct_abstract_declarator458);
                    	            expression53=expression();

                    	            state._fsp--;
                    	            if (state.failed) return retval;
                    	            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression53.getTree());

                    	            }
                    	            break;

                    	    }
                    	    } finally {dbg.exitSubRule(25);}

                    	    dbg.location(105,22);
                    	    char_literal54=(Token)match(input,56,FOLLOW_56_in_direct_abstract_declarator461); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal54_tree = (CommonTree)adaptor.create(char_literal54);
                    	    adaptor.addChild(root_0, char_literal54_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt26 >= 1 ) break loop26;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(26, input);
                                dbg.recognitionException(eee);

                                throw eee;
                        }
                        cnt26++;
                    } while (true);
                    } finally {dbg.exitSubRule(26);}


                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:106:5: ( '(' ( parameter_declaration_list )? ')' )+
                    {
                    dbg.location(106,5);
                    // F:\\workspace\\ESA\\grammar\\C.g:106:5: ( '(' ( parameter_declaration_list )? ')' )+
                    int cnt28=0;
                    try { dbg.enterSubRule(28);

                    loop28:
                    do {
                        int alt28=2;
                        try { dbg.enterDecision(28);

                        int LA28_0 = input.LA(1);

                        if ( (LA28_0==53) ) {
                            alt28=1;
                        }


                        } finally {dbg.exitDecision(28);}

                        switch (alt28) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // F:\\workspace\\ESA\\grammar\\C.g:106:6: '(' ( parameter_declaration_list )? ')'
                    	    {
                    	    dbg.location(106,6);
                    	    char_literal55=(Token)match(input,53,FOLLOW_53_in_direct_abstract_declarator472); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal55_tree = (CommonTree)adaptor.create(char_literal55);
                    	    adaptor.addChild(root_0, char_literal55_tree);
                    	    }
                    	    dbg.location(106,10);
                    	    // F:\\workspace\\ESA\\grammar\\C.g:106:10: ( parameter_declaration_list )?
                    	    int alt27=2;
                    	    try { dbg.enterSubRule(27);
                    	    try { dbg.enterDecision(27);

                    	    int LA27_0 = input.LA(1);

                    	    if ( (LA27_0==IDENTIFIER||(LA27_0>=58 && LA27_0<=74)||LA27_0==76) ) {
                    	        alt27=1;
                    	    }
                    	    } finally {dbg.exitDecision(27);}

                    	    switch (alt27) {
                    	        case 1 :
                    	            dbg.enterAlt(1);

                    	            // F:\\workspace\\ESA\\grammar\\C.g:106:10: parameter_declaration_list
                    	            {
                    	            dbg.location(106,10);
                    	            pushFollow(FOLLOW_parameter_declaration_list_in_direct_abstract_declarator474);
                    	            parameter_declaration_list56=parameter_declaration_list();

                    	            state._fsp--;
                    	            if (state.failed) return retval;
                    	            if ( state.backtracking==0 ) adaptor.addChild(root_0, parameter_declaration_list56.getTree());

                    	            }
                    	            break;

                    	    }
                    	    } finally {dbg.exitSubRule(27);}

                    	    dbg.location(106,38);
                    	    char_literal57=(Token)match(input,54,FOLLOW_54_in_direct_abstract_declarator477); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal57_tree = (CommonTree)adaptor.create(char_literal57);
                    	    adaptor.addChild(root_0, char_literal57_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt28 >= 1 ) break loop28;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(28, input);
                                dbg.recognitionException(eee);

                                throw eee;
                        }
                        cnt28++;
                    } while (true);
                    } finally {dbg.exitSubRule(28);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(29);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("direct_abstract_declarator", 14);
        }
        dbg.location(108, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "direct_abstract_declarator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "direct_abstract_declarator"

    public static class specifiers_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "specifiers"
    // F:\\workspace\\ESA\\grammar\\C.g:110:1: specifiers : ( storage_class_specifier | type_specifier | type_qualifier )+ ;
    public final CParser.specifiers_return specifiers() throws RecognitionException {
    traceIn("specifiers", 15);
        CParser.specifiers_return retval = new CParser.specifiers_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.storage_class_specifier_return storage_class_specifier58 = null;

        CParser.type_specifier_return type_specifier59 = null;

        CParser.type_qualifier_return type_qualifier60 = null;



        try { dbg.enterRule(getGrammarFileName(), "specifiers");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(110, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:111:2: ( ( storage_class_specifier | type_specifier | type_qualifier )+ )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:111:4: ( storage_class_specifier | type_specifier | type_qualifier )+
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(111,4);
            // F:\\workspace\\ESA\\grammar\\C.g:111:4: ( storage_class_specifier | type_specifier | type_qualifier )+
            int cnt30=0;
            try { dbg.enterSubRule(30);

            loop30:
            do {
                int alt30=4;
                try { dbg.enterDecision(30);

                switch ( input.LA(1) ) {
                case IDENTIFIER:
                    {
                    int LA30_2 = input.LA(2);

                    if ( (evalPredicate(isTypeName(input.LT(1).getText()),"isTypeName(input.LT(1).getText())")) ) {
                        alt30=2;
                    }


                    }
                    break;
                case 58:
                case 59:
                case 60:
                case 61:
                    {
                    alt30=1;
                    }
                    break;
                case 62:
                case 63:
                case 64:
                case 65:
                case 66:
                case 67:
                case 68:
                case 69:
                case 70:
                case 73:
                case 74:
                case 76:
                    {
                    alt30=2;
                    }
                    break;
                case 71:
                case 72:
                    {
                    alt30=3;
                    }
                    break;

                }

                } finally {dbg.exitDecision(30);}

                switch (alt30) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:111:5: storage_class_specifier
            	    {
            	    dbg.location(111,5);
            	    pushFollow(FOLLOW_storage_class_specifier_in_specifiers497);
            	    storage_class_specifier58=storage_class_specifier();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, storage_class_specifier58.getTree());

            	    }
            	    break;
            	case 2 :
            	    dbg.enterAlt(2);

            	    // F:\\workspace\\ESA\\grammar\\C.g:111:31: type_specifier
            	    {
            	    dbg.location(111,31);
            	    pushFollow(FOLLOW_type_specifier_in_specifiers501);
            	    type_specifier59=type_specifier();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, type_specifier59.getTree());

            	    }
            	    break;
            	case 3 :
            	    dbg.enterAlt(3);

            	    // F:\\workspace\\ESA\\grammar\\C.g:111:47: type_qualifier
            	    {
            	    dbg.location(111,47);
            	    pushFollow(FOLLOW_type_qualifier_in_specifiers504);
            	    type_qualifier60=type_qualifier();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, type_qualifier60.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt30 >= 1 ) break loop30;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(30, input);
                        dbg.recognitionException(eee);

                        throw eee;
                }
                cnt30++;
            } while (true);
            } finally {dbg.exitSubRule(30);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("specifiers", 15);
        }
        dbg.location(112, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "specifiers");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "specifiers"

    public static class storage_class_specifier_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "storage_class_specifier"
    // F:\\workspace\\ESA\\grammar\\C.g:114:1: storage_class_specifier : ( 'extern' | 'static' | 'auto' | 'register' );
    public final CParser.storage_class_specifier_return storage_class_specifier() throws RecognitionException {
    traceIn("storage_class_specifier", 16);
        CParser.storage_class_specifier_return retval = new CParser.storage_class_specifier_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set61=null;

        CommonTree set61_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "storage_class_specifier");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(114, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:115:2: ( 'extern' | 'static' | 'auto' | 'register' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(115,2);
            set61=(Token)input.LT(1);
            if ( (input.LA(1)>=58 && input.LA(1)<=61) ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set61));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("storage_class_specifier", 16);
        }
        dbg.location(115, 43);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "storage_class_specifier");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "storage_class_specifier"

    public static class type_specifier_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "type_specifier"
    // F:\\workspace\\ESA\\grammar\\C.g:117:1: type_specifier : ( 'void' | ( 'signed' | 'unsigned' )? ( 'short' | 'long' )? ( 'char' | 'int' | 'float' | 'double' ) | struct_or_union_specifier | enum_specifier | type_id );
    public final CParser.type_specifier_return type_specifier() throws RecognitionException {
    traceIn("type_specifier", 17);
        CParser.type_specifier_return retval = new CParser.type_specifier_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal62=null;
        Token set63=null;
        Token set64=null;
        Token set65=null;
        CParser.struct_or_union_specifier_return struct_or_union_specifier66 = null;

        CParser.enum_specifier_return enum_specifier67 = null;

        CParser.type_id_return type_id68 = null;


        CommonTree string_literal62_tree=null;
        CommonTree set63_tree=null;
        CommonTree set64_tree=null;
        CommonTree set65_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "type_specifier");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(117, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:118:2: ( 'void' | ( 'signed' | 'unsigned' )? ( 'short' | 'long' )? ( 'char' | 'int' | 'float' | 'double' ) | struct_or_union_specifier | enum_specifier | type_id )
            int alt33=5;
            try { dbg.enterDecision(33);

            switch ( input.LA(1) ) {
            case 62:
                {
                alt33=1;
                }
                break;
            case 63:
            case 64:
            case 65:
            case 66:
            case 67:
            case 68:
            case 69:
            case 70:
                {
                alt33=2;
                }
                break;
            case 73:
            case 74:
                {
                alt33=3;
                }
                break;
            case 76:
                {
                alt33=4;
                }
                break;
            case IDENTIFIER:
                {
                alt33=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 33, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(33);}

            switch (alt33) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:118:4: 'void'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(118,4);
                    string_literal62=(Token)match(input,62,FOLLOW_62_in_type_specifier536); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal62_tree = (CommonTree)adaptor.create(string_literal62);
                    adaptor.addChild(root_0, string_literal62_tree);
                    }

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:119:4: ( 'signed' | 'unsigned' )? ( 'short' | 'long' )? ( 'char' | 'int' | 'float' | 'double' )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(119,4);
                    // F:\\workspace\\ESA\\grammar\\C.g:119:4: ( 'signed' | 'unsigned' )?
                    int alt31=2;
                    try { dbg.enterSubRule(31);
                    try { dbg.enterDecision(31);

                    int LA31_0 = input.LA(1);

                    if ( ((LA31_0>=63 && LA31_0<=64)) ) {
                        alt31=1;
                    }
                    } finally {dbg.exitDecision(31);}

                    switch (alt31) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:
                            {
                            dbg.location(119,4);
                            set63=(Token)input.LT(1);
                            if ( (input.LA(1)>=63 && input.LA(1)<=64) ) {
                                input.consume();
                                if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set63));
                                state.errorRecovery=false;state.failed=false;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                MismatchedSetException mse = new MismatchedSetException(null,input);
                                dbg.recognitionException(mse);
                                throw mse;
                            }


                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(31);}

                    dbg.location(119,28);
                    // F:\\workspace\\ESA\\grammar\\C.g:119:28: ( 'short' | 'long' )?
                    int alt32=2;
                    try { dbg.enterSubRule(32);
                    try { dbg.enterDecision(32);

                    int LA32_0 = input.LA(1);

                    if ( ((LA32_0>=65 && LA32_0<=66)) ) {
                        alt32=1;
                    }
                    } finally {dbg.exitDecision(32);}

                    switch (alt32) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:
                            {
                            dbg.location(119,28);
                            set64=(Token)input.LT(1);
                            if ( (input.LA(1)>=65 && input.LA(1)<=66) ) {
                                input.consume();
                                if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set64));
                                state.errorRecovery=false;state.failed=false;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                MismatchedSetException mse = new MismatchedSetException(null,input);
                                dbg.recognitionException(mse);
                                throw mse;
                            }


                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(32);}

                    dbg.location(119,46);
                    set65=(Token)input.LT(1);
                    if ( (input.LA(1)>=67 && input.LA(1)<=70) ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set65));
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:120:4: struct_or_union_specifier
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(120,4);
                    pushFollow(FOLLOW_struct_or_union_specifier_in_type_specifier569);
                    struct_or_union_specifier66=struct_or_union_specifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, struct_or_union_specifier66.getTree());

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // F:\\workspace\\ESA\\grammar\\C.g:121:4: enum_specifier
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(121,4);
                    pushFollow(FOLLOW_enum_specifier_in_type_specifier574);
                    enum_specifier67=enum_specifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, enum_specifier67.getTree());

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // F:\\workspace\\ESA\\grammar\\C.g:122:4: type_id
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(122,4);
                    pushFollow(FOLLOW_type_id_in_type_specifier579);
                    type_id68=type_id();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type_id68.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("type_specifier", 17);
        }
        dbg.location(123, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "type_specifier");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "type_specifier"

    public static class type_qualifier_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "type_qualifier"
    // F:\\workspace\\ESA\\grammar\\C.g:125:1: type_qualifier : ( 'const' | 'volatile' );
    public final CParser.type_qualifier_return type_qualifier() throws RecognitionException {
    traceIn("type_qualifier", 18);
        CParser.type_qualifier_return retval = new CParser.type_qualifier_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set69=null;

        CommonTree set69_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "type_qualifier");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(125, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:126:2: ( 'const' | 'volatile' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(126,2);
            set69=(Token)input.LT(1);
            if ( (input.LA(1)>=71 && input.LA(1)<=72) ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set69));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("type_qualifier", 18);
        }
        dbg.location(128, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "type_qualifier");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "type_qualifier"

    public static class type_id_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "type_id"
    // F:\\workspace\\ESA\\grammar\\C.g:130:1: type_id : {...}? IDENTIFIER ;
    public final CParser.type_id_return type_id() throws RecognitionException {
    traceIn("type_id", 19);
        CParser.type_id_return retval = new CParser.type_id_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENTIFIER70=null;

        CommonTree IDENTIFIER70_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "type_id");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(130, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:131:5: ({...}? IDENTIFIER )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:131:9: {...}? IDENTIFIER
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(131,9);
            if ( !(evalPredicate(isTypeName(input.LT(1).getText()),"isTypeName(input.LT(1).getText())")) ) {
                if (state.backtracking>0) {state.failed=true; return retval;}
                throw new FailedPredicateException(input, "type_id", "isTypeName(input.LT(1).getText())");
            }
            dbg.location(131,46);
            IDENTIFIER70=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_type_id614); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER70_tree = (CommonTree)adaptor.create(IDENTIFIER70);
            adaptor.addChild(root_0, IDENTIFIER70_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("type_id", 19);
        }
        dbg.location(132, 5);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "type_id");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "type_id"

    public static class struct_or_union_specifier_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "struct_or_union_specifier"
    // F:\\workspace\\ESA\\grammar\\C.g:134:1: struct_or_union_specifier options {k=3; } : ( ( 'struct' | 'union' ) ( IDENTIFIER )? '{' struct_declaration_list '}' | ( 'struct' | 'union' ) IDENTIFIER );
    public final CParser.struct_or_union_specifier_return struct_or_union_specifier() throws RecognitionException {
    traceIn("struct_or_union_specifier", 20);
        Scope2_stack.push(new Scope2_scope());

        CParser.struct_or_union_specifier_return retval = new CParser.struct_or_union_specifier_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set71=null;
        Token IDENTIFIER72=null;
        Token char_literal73=null;
        Token char_literal75=null;
        Token set76=null;
        Token IDENTIFIER77=null;
        CParser.struct_declaration_list_return struct_declaration_list74 = null;


        CommonTree set71_tree=null;
        CommonTree IDENTIFIER72_tree=null;
        CommonTree char_literal73_tree=null;
        CommonTree char_literal75_tree=null;
        CommonTree set76_tree=null;
        CommonTree IDENTIFIER77_tree=null;

         // 3 lookup tables
          ((Scope2_scope)Scope2_stack.peek()).types = new HashSet<String>(); // global shared variable/function declaration, typedef

        try { dbg.enterRule(getGrammarFileName(), "struct_or_union_specifier");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(134, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:137:3: ( ( 'struct' | 'union' ) ( IDENTIFIER )? '{' struct_declaration_list '}' | ( 'struct' | 'union' ) IDENTIFIER )
            int alt35=2;
            try { dbg.enterDecision(35);

            try {
                isCyclicDecision = true;
                alt35 = dfa35.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(35);}

            switch (alt35) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:137:5: ( 'struct' | 'union' ) ( IDENTIFIER )? '{' struct_declaration_list '}'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(137,5);
                    set71=(Token)input.LT(1);
                    if ( (input.LA(1)>=73 && input.LA(1)<=74) ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set71));
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }

                    dbg.location(137,24);
                    // F:\\workspace\\ESA\\grammar\\C.g:137:24: ( IDENTIFIER )?
                    int alt34=2;
                    try { dbg.enterSubRule(34);
                    try { dbg.enterDecision(34);

                    int LA34_0 = input.LA(1);

                    if ( (LA34_0==IDENTIFIER) ) {
                        alt34=1;
                    }
                    } finally {dbg.exitDecision(34);}

                    switch (alt34) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:137:24: IDENTIFIER
                            {
                            dbg.location(137,24);
                            IDENTIFIER72=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_struct_or_union_specifier651); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            IDENTIFIER72_tree = (CommonTree)adaptor.create(IDENTIFIER72);
                            adaptor.addChild(root_0, IDENTIFIER72_tree);
                            }

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(34);}

                    dbg.location(137,36);
                    char_literal73=(Token)match(input,47,FOLLOW_47_in_struct_or_union_specifier654); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal73_tree = (CommonTree)adaptor.create(char_literal73);
                    adaptor.addChild(root_0, char_literal73_tree);
                    }
                    dbg.location(137,40);
                    pushFollow(FOLLOW_struct_declaration_list_in_struct_or_union_specifier656);
                    struct_declaration_list74=struct_declaration_list();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, struct_declaration_list74.getTree());
                    dbg.location(137,64);
                    char_literal75=(Token)match(input,48,FOLLOW_48_in_struct_or_union_specifier658); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal75_tree = (CommonTree)adaptor.create(char_literal75);
                    adaptor.addChild(root_0, char_literal75_tree);
                    }

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:138:4: ( 'struct' | 'union' ) IDENTIFIER
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(138,4);
                    set76=(Token)input.LT(1);
                    if ( (input.LA(1)>=73 && input.LA(1)<=74) ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set76));
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }

                    dbg.location(138,23);
                    IDENTIFIER77=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_struct_or_union_specifier669); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER77_tree = (CommonTree)adaptor.create(IDENTIFIER77);
                    adaptor.addChild(root_0, IDENTIFIER77_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("struct_or_union_specifier", 20);
            Scope2_stack.pop();

        }
        dbg.location(139, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "struct_or_union_specifier");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "struct_or_union_specifier"

    public static class struct_declaration_list_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "struct_declaration_list"
    // F:\\workspace\\ESA\\grammar\\C.g:141:1: struct_declaration_list : ( struct_declaration )+ ;
    public final CParser.struct_declaration_list_return struct_declaration_list() throws RecognitionException {
    traceIn("struct_declaration_list", 21);
        CParser.struct_declaration_list_return retval = new CParser.struct_declaration_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.struct_declaration_return struct_declaration78 = null;



        try { dbg.enterRule(getGrammarFileName(), "struct_declaration_list");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(141, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:142:2: ( ( struct_declaration )+ )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:142:4: ( struct_declaration )+
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(142,4);
            // F:\\workspace\\ESA\\grammar\\C.g:142:4: ( struct_declaration )+
            int cnt36=0;
            try { dbg.enterSubRule(36);

            loop36:
            do {
                int alt36=2;
                try { dbg.enterDecision(36);

                int LA36_0 = input.LA(1);

                if ( (LA36_0==IDENTIFIER||(LA36_0>=58 && LA36_0<=74)||LA36_0==76) ) {
                    alt36=1;
                }


                } finally {dbg.exitDecision(36);}

                switch (alt36) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:142:4: struct_declaration
            	    {
            	    dbg.location(142,4);
            	    pushFollow(FOLLOW_struct_declaration_in_struct_declaration_list680);
            	    struct_declaration78=struct_declaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, struct_declaration78.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt36 >= 1 ) break loop36;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(36, input);
                        dbg.recognitionException(eee);

                        throw eee;
                }
                cnt36++;
            } while (true);
            } finally {dbg.exitSubRule(36);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("struct_declaration_list", 21);
        }
        dbg.location(143, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "struct_declaration_list");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "struct_declaration_list"

    public static class struct_declaration_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "struct_declaration"
    // F:\\workspace\\ESA\\grammar\\C.g:145:1: struct_declaration : specifiers struct_declarator_list ';' ;
    public final CParser.struct_declaration_return struct_declaration() throws RecognitionException {
    traceIn("struct_declaration", 22);
        CParser.struct_declaration_return retval = new CParser.struct_declaration_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal81=null;
        CParser.specifiers_return specifiers79 = null;

        CParser.struct_declarator_list_return struct_declarator_list80 = null;


        CommonTree char_literal81_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "struct_declaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(145, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:146:2: ( specifiers struct_declarator_list ';' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:146:4: specifiers struct_declarator_list ';'
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(146,4);
            pushFollow(FOLLOW_specifiers_in_struct_declaration692);
            specifiers79=specifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, specifiers79.getTree());
            dbg.location(146,15);
            pushFollow(FOLLOW_struct_declarator_list_in_struct_declaration694);
            struct_declarator_list80=struct_declarator_list();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, struct_declarator_list80.getTree());
            dbg.location(146,38);
            char_literal81=(Token)match(input,50,FOLLOW_50_in_struct_declaration696); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal81_tree = (CommonTree)adaptor.create(char_literal81);
            adaptor.addChild(root_0, char_literal81_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("struct_declaration", 22);
        }
        dbg.location(147, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "struct_declaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "struct_declaration"

    public static class struct_declarator_list_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "struct_declarator_list"
    // F:\\workspace\\ESA\\grammar\\C.g:149:1: struct_declarator_list : struct_declarator ( ',' struct_declarator )* ;
    public final CParser.struct_declarator_list_return struct_declarator_list() throws RecognitionException {
    traceIn("struct_declarator_list", 23);
        CParser.struct_declarator_list_return retval = new CParser.struct_declarator_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal83=null;
        CParser.struct_declarator_return struct_declarator82 = null;

        CParser.struct_declarator_return struct_declarator84 = null;


        CommonTree char_literal83_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "struct_declarator_list");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(149, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:150:2: ( struct_declarator ( ',' struct_declarator )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:150:4: struct_declarator ( ',' struct_declarator )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(150,4);
            pushFollow(FOLLOW_struct_declarator_in_struct_declarator_list707);
            struct_declarator82=struct_declarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, struct_declarator82.getTree());
            dbg.location(150,22);
            // F:\\workspace\\ESA\\grammar\\C.g:150:22: ( ',' struct_declarator )*
            try { dbg.enterSubRule(37);

            loop37:
            do {
                int alt37=2;
                try { dbg.enterDecision(37);

                int LA37_0 = input.LA(1);

                if ( (LA37_0==51) ) {
                    alt37=1;
                }


                } finally {dbg.exitDecision(37);}

                switch (alt37) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:150:23: ',' struct_declarator
            	    {
            	    dbg.location(150,23);
            	    char_literal83=(Token)match(input,51,FOLLOW_51_in_struct_declarator_list710); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal83_tree = (CommonTree)adaptor.create(char_literal83);
            	    adaptor.addChild(root_0, char_literal83_tree);
            	    }
            	    dbg.location(150,27);
            	    pushFollow(FOLLOW_struct_declarator_in_struct_declarator_list712);
            	    struct_declarator84=struct_declarator();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, struct_declarator84.getTree());

            	    }
            	    break;

            	default :
            	    break loop37;
                }
            } while (true);
            } finally {dbg.exitSubRule(37);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("struct_declarator_list", 23);
        }
        dbg.location(151, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "struct_declarator_list");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "struct_declarator_list"

    public static class struct_declarator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "struct_declarator"
    // F:\\workspace\\ESA\\grammar\\C.g:153:1: struct_declarator : ( ( ( declarator )? ':' )=> ( declarator )? ( ':' expression ) | declarator );
    public final CParser.struct_declarator_return struct_declarator() throws RecognitionException {
    traceIn("struct_declarator", 24);
        CParser.struct_declarator_return retval = new CParser.struct_declarator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal86=null;
        CParser.declarator_return declarator85 = null;

        CParser.expression_return expression87 = null;

        CParser.declarator_return declarator88 = null;


        CommonTree char_literal86_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "struct_declarator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(153, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:154:2: ( ( ( declarator )? ':' )=> ( declarator )? ( ':' expression ) | declarator )
            int alt39=2;
            try { dbg.enterDecision(39);

            int LA39_0 = input.LA(1);

            if ( (LA39_0==MUL) ) {
                int LA39_1 = input.LA(2);

                if ( (synpred2_C()) ) {
                    alt39=1;
                }
                else if ( (true) ) {
                    alt39=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else if ( (LA39_0==IDENTIFIER) ) {
                int LA39_2 = input.LA(2);

                if ( (synpred2_C()) ) {
                    alt39=1;
                }
                else if ( (true) ) {
                    alt39=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else if ( (LA39_0==53) ) {
                int LA39_3 = input.LA(2);

                if ( (synpred2_C()) ) {
                    alt39=1;
                }
                else if ( (true) ) {
                    alt39=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 3, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else if ( (LA39_0==75) && (synpred2_C())) {
                alt39=1;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 39, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(39);}

            switch (alt39) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:154:4: ( ( declarator )? ':' )=> ( declarator )? ( ':' expression )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(154,24);
                    // F:\\workspace\\ESA\\grammar\\C.g:154:24: ( declarator )?
                    int alt38=2;
                    try { dbg.enterSubRule(38);
                    try { dbg.enterDecision(38);

                    int LA38_0 = input.LA(1);

                    if ( (LA38_0==IDENTIFIER||LA38_0==MUL||LA38_0==53) ) {
                        alt38=1;
                    }
                    } finally {dbg.exitDecision(38);}

                    switch (alt38) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:154:24: declarator
                            {
                            dbg.location(154,24);
                            pushFollow(FOLLOW_declarator_in_struct_declarator733);
                            declarator85=declarator();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, declarator85.getTree());

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(38);}

                    dbg.location(154,36);
                    // F:\\workspace\\ESA\\grammar\\C.g:154:36: ( ':' expression )
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:154:37: ':' expression
                    {
                    dbg.location(154,37);
                    char_literal86=(Token)match(input,75,FOLLOW_75_in_struct_declarator737); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal86_tree = (CommonTree)adaptor.create(char_literal86);
                    adaptor.addChild(root_0, char_literal86_tree);
                    }
                    dbg.location(154,41);
                    pushFollow(FOLLOW_expression_in_struct_declarator739);
                    expression87=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression87.getTree());

                    }


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:155:4: declarator
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(155,4);
                    pushFollow(FOLLOW_declarator_in_struct_declarator745);
                    declarator88=declarator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, declarator88.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("struct_declarator", 24);
        }
        dbg.location(156, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "struct_declarator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "struct_declarator"

    public static class enum_specifier_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "enum_specifier"
    // F:\\workspace\\ESA\\grammar\\C.g:158:1: enum_specifier options {k=3; } : ( 'enum' ( IDENTIFIER )? '{' enumerator_list '}' | 'enum' IDENTIFIER );
    public final CParser.enum_specifier_return enum_specifier() throws RecognitionException {
    traceIn("enum_specifier", 25);
        CParser.enum_specifier_return retval = new CParser.enum_specifier_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal89=null;
        Token IDENTIFIER90=null;
        Token char_literal91=null;
        Token char_literal93=null;
        Token string_literal94=null;
        Token IDENTIFIER95=null;
        CParser.enumerator_list_return enumerator_list92 = null;


        CommonTree string_literal89_tree=null;
        CommonTree IDENTIFIER90_tree=null;
        CommonTree char_literal91_tree=null;
        CommonTree char_literal93_tree=null;
        CommonTree string_literal94_tree=null;
        CommonTree IDENTIFIER95_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "enum_specifier");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(158, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:159:2: ( 'enum' ( IDENTIFIER )? '{' enumerator_list '}' | 'enum' IDENTIFIER )
            int alt41=2;
            try { dbg.enterDecision(41);

            try {
                isCyclicDecision = true;
                alt41 = dfa41.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(41);}

            switch (alt41) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:159:4: 'enum' ( IDENTIFIER )? '{' enumerator_list '}'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(159,4);
                    string_literal89=(Token)match(input,76,FOLLOW_76_in_enum_specifier763); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal89_tree = (CommonTree)adaptor.create(string_literal89);
                    adaptor.addChild(root_0, string_literal89_tree);
                    }
                    dbg.location(159,11);
                    // F:\\workspace\\ESA\\grammar\\C.g:159:11: ( IDENTIFIER )?
                    int alt40=2;
                    try { dbg.enterSubRule(40);
                    try { dbg.enterDecision(40);

                    int LA40_0 = input.LA(1);

                    if ( (LA40_0==IDENTIFIER) ) {
                        alt40=1;
                    }
                    } finally {dbg.exitDecision(40);}

                    switch (alt40) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:159:11: IDENTIFIER
                            {
                            dbg.location(159,11);
                            IDENTIFIER90=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enum_specifier765); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            IDENTIFIER90_tree = (CommonTree)adaptor.create(IDENTIFIER90);
                            adaptor.addChild(root_0, IDENTIFIER90_tree);
                            }

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(40);}

                    dbg.location(159,23);
                    char_literal91=(Token)match(input,47,FOLLOW_47_in_enum_specifier768); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal91_tree = (CommonTree)adaptor.create(char_literal91);
                    adaptor.addChild(root_0, char_literal91_tree);
                    }
                    dbg.location(159,27);
                    pushFollow(FOLLOW_enumerator_list_in_enum_specifier770);
                    enumerator_list92=enumerator_list();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, enumerator_list92.getTree());
                    dbg.location(159,43);
                    char_literal93=(Token)match(input,48,FOLLOW_48_in_enum_specifier772); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal93_tree = (CommonTree)adaptor.create(char_literal93);
                    adaptor.addChild(root_0, char_literal93_tree);
                    }

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:160:4: 'enum' IDENTIFIER
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(160,4);
                    string_literal94=(Token)match(input,76,FOLLOW_76_in_enum_specifier777); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal94_tree = (CommonTree)adaptor.create(string_literal94);
                    adaptor.addChild(root_0, string_literal94_tree);
                    }
                    dbg.location(160,11);
                    IDENTIFIER95=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enum_specifier779); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER95_tree = (CommonTree)adaptor.create(IDENTIFIER95);
                    adaptor.addChild(root_0, IDENTIFIER95_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("enum_specifier", 25);
        }
        dbg.location(161, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "enum_specifier");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "enum_specifier"

    public static class enumerator_list_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "enumerator_list"
    // F:\\workspace\\ESA\\grammar\\C.g:163:1: enumerator_list : enumerator ( ',' enumerator )* ;
    public final CParser.enumerator_list_return enumerator_list() throws RecognitionException {
    traceIn("enumerator_list", 26);
        CParser.enumerator_list_return retval = new CParser.enumerator_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal97=null;
        CParser.enumerator_return enumerator96 = null;

        CParser.enumerator_return enumerator98 = null;


        CommonTree char_literal97_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "enumerator_list");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(163, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:164:2: ( enumerator ( ',' enumerator )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:164:4: enumerator ( ',' enumerator )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(164,4);
            pushFollow(FOLLOW_enumerator_in_enumerator_list790);
            enumerator96=enumerator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, enumerator96.getTree());
            dbg.location(164,15);
            // F:\\workspace\\ESA\\grammar\\C.g:164:15: ( ',' enumerator )*
            try { dbg.enterSubRule(42);

            loop42:
            do {
                int alt42=2;
                try { dbg.enterDecision(42);

                int LA42_0 = input.LA(1);

                if ( (LA42_0==51) ) {
                    alt42=1;
                }


                } finally {dbg.exitDecision(42);}

                switch (alt42) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:164:16: ',' enumerator
            	    {
            	    dbg.location(164,16);
            	    char_literal97=(Token)match(input,51,FOLLOW_51_in_enumerator_list793); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal97_tree = (CommonTree)adaptor.create(char_literal97);
            	    adaptor.addChild(root_0, char_literal97_tree);
            	    }
            	    dbg.location(164,20);
            	    pushFollow(FOLLOW_enumerator_in_enumerator_list795);
            	    enumerator98=enumerator();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, enumerator98.getTree());

            	    }
            	    break;

            	default :
            	    break loop42;
                }
            } while (true);
            } finally {dbg.exitSubRule(42);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("enumerator_list", 26);
        }
        dbg.location(165, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "enumerator_list");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "enumerator_list"

    public static class enumerator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "enumerator"
    // F:\\workspace\\ESA\\grammar\\C.g:167:1: enumerator : IDENTIFIER ( '=' expression )? ;
    public final CParser.enumerator_return enumerator() throws RecognitionException {
    traceIn("enumerator", 27);
        CParser.enumerator_return retval = new CParser.enumerator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENTIFIER99=null;
        Token char_literal100=null;
        CParser.expression_return expression101 = null;


        CommonTree IDENTIFIER99_tree=null;
        CommonTree char_literal100_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "enumerator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(167, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:168:2: ( IDENTIFIER ( '=' expression )? )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:168:4: IDENTIFIER ( '=' expression )?
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(168,4);
            IDENTIFIER99=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumerator808); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER99_tree = (CommonTree)adaptor.create(IDENTIFIER99);
            adaptor.addChild(root_0, IDENTIFIER99_tree);
            }
            dbg.location(168,15);
            // F:\\workspace\\ESA\\grammar\\C.g:168:15: ( '=' expression )?
            int alt43=2;
            try { dbg.enterSubRule(43);
            try { dbg.enterDecision(43);

            int LA43_0 = input.LA(1);

            if ( (LA43_0==52) ) {
                alt43=1;
            }
            } finally {dbg.exitDecision(43);}

            switch (alt43) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:168:16: '=' expression
                    {
                    dbg.location(168,16);
                    char_literal100=(Token)match(input,52,FOLLOW_52_in_enumerator811); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal100_tree = (CommonTree)adaptor.create(char_literal100);
                    adaptor.addChild(root_0, char_literal100_tree);
                    }
                    dbg.location(168,20);
                    pushFollow(FOLLOW_expression_in_enumerator813);
                    expression101=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression101.getTree());

                    }
                    break;

            }
            } finally {dbg.exitSubRule(43);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("enumerator", 27);
        }
        dbg.location(169, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "enumerator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "enumerator"

    public static class initializer_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "initializer"
    // F:\\workspace\\ESA\\grammar\\C.g:173:1: initializer : ( assignment_expression | '{' ( initializer_list )? '}' );
    public final CParser.initializer_return initializer() throws RecognitionException {
    traceIn("initializer", 28);
        CParser.initializer_return retval = new CParser.initializer_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal103=null;
        Token char_literal105=null;
        CParser.assignment_expression_return assignment_expression102 = null;

        CParser.initializer_list_return initializer_list104 = null;


        CommonTree char_literal103_tree=null;
        CommonTree char_literal105_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "initializer");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(173, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:174:2: ( assignment_expression | '{' ( initializer_list )? '}' )
            int alt45=2;
            try { dbg.enterDecision(45);

            int LA45_0 = input.LA(1);

            if ( ((LA45_0>=IDENTIFIER && LA45_0<=DEC)||(LA45_0>=NEG && LA45_0<=BIT_AND)||LA45_0==BIT_NEG||LA45_0==MUL||(LA45_0>=PLUS && LA45_0<=STRING_LITERAL)||LA45_0==53||LA45_0==84) ) {
                alt45=1;
            }
            else if ( (LA45_0==47) ) {
                alt45=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 45, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(45);}

            switch (alt45) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:174:4: assignment_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(174,4);
                    pushFollow(FOLLOW_assignment_expression_in_initializer828);
                    assignment_expression102=assignment_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignment_expression102.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:175:4: '{' ( initializer_list )? '}'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(175,4);
                    char_literal103=(Token)match(input,47,FOLLOW_47_in_initializer833); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal103_tree = (CommonTree)adaptor.create(char_literal103);
                    adaptor.addChild(root_0, char_literal103_tree);
                    }
                    dbg.location(175,8);
                    // F:\\workspace\\ESA\\grammar\\C.g:175:8: ( initializer_list )?
                    int alt44=2;
                    try { dbg.enterSubRule(44);
                    try { dbg.enterDecision(44);

                    int LA44_0 = input.LA(1);

                    if ( ((LA44_0>=IDENTIFIER && LA44_0<=DEC)||(LA44_0>=NEG && LA44_0<=BIT_AND)||LA44_0==BIT_NEG||LA44_0==MUL||(LA44_0>=PLUS && LA44_0<=STRING_LITERAL)||LA44_0==47||LA44_0==53||LA44_0==84) ) {
                        alt44=1;
                    }
                    } finally {dbg.exitDecision(44);}

                    switch (alt44) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:175:8: initializer_list
                            {
                            dbg.location(175,8);
                            pushFollow(FOLLOW_initializer_list_in_initializer835);
                            initializer_list104=initializer_list();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, initializer_list104.getTree());

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(44);}

                    dbg.location(175,26);
                    char_literal105=(Token)match(input,48,FOLLOW_48_in_initializer838); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal105_tree = (CommonTree)adaptor.create(char_literal105);
                    adaptor.addChild(root_0, char_literal105_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("initializer", 28);
        }
        dbg.location(176, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "initializer");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "initializer"

    public static class initializer_list_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "initializer_list"
    // F:\\workspace\\ESA\\grammar\\C.g:177:1: initializer_list : initializer ( ',' initializer )* ;
    public final CParser.initializer_list_return initializer_list() throws RecognitionException {
    traceIn("initializer_list", 29);
        CParser.initializer_list_return retval = new CParser.initializer_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal107=null;
        CParser.initializer_return initializer106 = null;

        CParser.initializer_return initializer108 = null;


        CommonTree char_literal107_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "initializer_list");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(177, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:178:2: ( initializer ( ',' initializer )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:178:4: initializer ( ',' initializer )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(178,4);
            pushFollow(FOLLOW_initializer_in_initializer_list848);
            initializer106=initializer();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, initializer106.getTree());
            dbg.location(178,16);
            // F:\\workspace\\ESA\\grammar\\C.g:178:16: ( ',' initializer )*
            try { dbg.enterSubRule(46);

            loop46:
            do {
                int alt46=2;
                try { dbg.enterDecision(46);

                int LA46_0 = input.LA(1);

                if ( (LA46_0==51) ) {
                    alt46=1;
                }


                } finally {dbg.exitDecision(46);}

                switch (alt46) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:178:17: ',' initializer
            	    {
            	    dbg.location(178,17);
            	    char_literal107=(Token)match(input,51,FOLLOW_51_in_initializer_list851); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal107_tree = (CommonTree)adaptor.create(char_literal107);
            	    adaptor.addChild(root_0, char_literal107_tree);
            	    }
            	    dbg.location(178,21);
            	    pushFollow(FOLLOW_initializer_in_initializer_list853);
            	    initializer108=initializer();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, initializer108.getTree());

            	    }
            	    break;

            	default :
            	    break loop46;
                }
            } while (true);
            } finally {dbg.exitSubRule(46);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("initializer_list", 29);
        }
        dbg.location(179, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "initializer_list");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "initializer_list"

    public static class argument_expression_list_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "argument_expression_list"
    // F:\\workspace\\ESA\\grammar\\C.g:182:1: argument_expression_list : assignment_expression ( ',' assignment_expression )* ;
    public final CParser.argument_expression_list_return argument_expression_list() throws RecognitionException {
    traceIn("argument_expression_list", 30);
        CParser.argument_expression_list_return retval = new CParser.argument_expression_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal110=null;
        CParser.assignment_expression_return assignment_expression109 = null;

        CParser.assignment_expression_return assignment_expression111 = null;


        CommonTree char_literal110_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "argument_expression_list");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(182, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:183:2: ( assignment_expression ( ',' assignment_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:183:6: assignment_expression ( ',' assignment_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(183,6);
            pushFollow(FOLLOW_assignment_expression_in_argument_expression_list869);
            assignment_expression109=assignment_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, assignment_expression109.getTree());
            dbg.location(183,28);
            // F:\\workspace\\ESA\\grammar\\C.g:183:28: ( ',' assignment_expression )*
            try { dbg.enterSubRule(47);

            loop47:
            do {
                int alt47=2;
                try { dbg.enterDecision(47);

                int LA47_0 = input.LA(1);

                if ( (LA47_0==51) ) {
                    alt47=1;
                }


                } finally {dbg.exitDecision(47);}

                switch (alt47) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:183:29: ',' assignment_expression
            	    {
            	    dbg.location(183,29);
            	    char_literal110=(Token)match(input,51,FOLLOW_51_in_argument_expression_list872); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal110_tree = (CommonTree)adaptor.create(char_literal110);
            	    adaptor.addChild(root_0, char_literal110_tree);
            	    }
            	    dbg.location(183,33);
            	    pushFollow(FOLLOW_assignment_expression_in_argument_expression_list874);
            	    assignment_expression111=assignment_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignment_expression111.getTree());

            	    }
            	    break;

            	default :
            	    break loop47;
                }
            } while (true);
            } finally {dbg.exitSubRule(47);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("argument_expression_list", 30);
        }
        dbg.location(184, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "argument_expression_list");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "argument_expression_list"

    public static class expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expression"
    // F:\\workspace\\ESA\\grammar\\C.g:186:1: expression options {memoize=true; } : assignment_expression ;
    public final CParser.expression_return expression() throws RecognitionException {
    traceIn("expression", 31);
        CParser.expression_return retval = new CParser.expression_return();
        retval.start = input.LT(1);
        int expression_StartIndex = input.index();
        CommonTree root_0 = null;

        CParser.assignment_expression_return assignment_expression112 = null;



        try { dbg.enterRule(getGrammarFileName(), "expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(186, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return retval; }
            // F:\\workspace\\ESA\\grammar\\C.g:187:2: ( assignment_expression )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:187:4: assignment_expression
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(187,4);
            pushFollow(FOLLOW_assignment_expression_in_expression895);
            assignment_expression112=assignment_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, assignment_expression112.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("expression", 31);
            if ( state.backtracking>0 ) { memoize(input, 31, expression_StartIndex); }
        }
        dbg.location(188, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "expression"

    public static class assignment_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assignment_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:190:1: assignment_expression : ( ( lvalue assign_op )=> lvalue assign_op assignment_expression | conditional_expression );
    public final CParser.assignment_expression_return assignment_expression() throws RecognitionException {
    traceIn("assignment_expression", 32);
        CParser.assignment_expression_return retval = new CParser.assignment_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.lvalue_return lvalue113 = null;

        CParser.assign_op_return assign_op114 = null;

        CParser.assignment_expression_return assignment_expression115 = null;

        CParser.conditional_expression_return conditional_expression116 = null;



        try { dbg.enterRule(getGrammarFileName(), "assignment_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(190, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:191:2: ( ( lvalue assign_op )=> lvalue assign_op assignment_expression | conditional_expression )
            int alt48=2;
            try { dbg.enterDecision(48);

            try {
                isCyclicDecision = true;
                alt48 = dfa48.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(48);}

            switch (alt48) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:191:4: ( lvalue assign_op )=> lvalue assign_op assignment_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(191,25);
                    pushFollow(FOLLOW_lvalue_in_assignment_expression913);
                    lvalue113=lvalue();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, lvalue113.getTree());
                    dbg.location(191,32);
                    pushFollow(FOLLOW_assign_op_in_assignment_expression915);
                    assign_op114=assign_op();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assign_op114.getTree());
                    dbg.location(191,42);
                    pushFollow(FOLLOW_assignment_expression_in_assignment_expression917);
                    assignment_expression115=assignment_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignment_expression115.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:192:4: conditional_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(192,4);
                    pushFollow(FOLLOW_conditional_expression_in_assignment_expression922);
                    conditional_expression116=conditional_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditional_expression116.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("assignment_expression", 32);
        }
        dbg.location(193, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "assignment_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "assignment_expression"

    public static class lvalue_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "lvalue"
    // F:\\workspace\\ESA\\grammar\\C.g:194:1: lvalue : ( INC | DEC )? prefix_expression ;
    public final CParser.lvalue_return lvalue() throws RecognitionException {
    traceIn("lvalue", 33);
        CParser.lvalue_return retval = new CParser.lvalue_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set117=null;
        CParser.prefix_expression_return prefix_expression118 = null;


        CommonTree set117_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "lvalue");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(194, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:195:2: ( ( INC | DEC )? prefix_expression )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:195:4: ( INC | DEC )? prefix_expression
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(195,4);
            // F:\\workspace\\ESA\\grammar\\C.g:195:4: ( INC | DEC )?
            int alt49=2;
            try { dbg.enterSubRule(49);
            try { dbg.enterDecision(49);

            int LA49_0 = input.LA(1);

            if ( ((LA49_0>=INC && LA49_0<=DEC)) ) {
                alt49=1;
            }
            } finally {dbg.exitDecision(49);}

            switch (alt49) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:
                    {
                    dbg.location(195,4);
                    set117=(Token)input.LT(1);
                    if ( (input.LA(1)>=INC && input.LA(1)<=DEC) ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set117));
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;

            }
            } finally {dbg.exitSubRule(49);}

            dbg.location(195,15);
            pushFollow(FOLLOW_prefix_expression_in_lvalue939);
            prefix_expression118=prefix_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, prefix_expression118.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("lvalue", 33);
        }
        dbg.location(196, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "lvalue");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "lvalue"

    public static class assign_op_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assign_op"
    // F:\\workspace\\ESA\\grammar\\C.g:197:1: assign_op : ( AND | OR | NEG | BIT_AND | BIT_OR | BIT_NEG | BIT_XOR | BIT_SHL | BIT_SHR | MUL | DIV | MOD | PLUS | SURPLUS )? '=' ;
    public final CParser.assign_op_return assign_op() throws RecognitionException {
    traceIn("assign_op", 34);
        CParser.assign_op_return retval = new CParser.assign_op_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set119=null;
        Token char_literal120=null;

        CommonTree set119_tree=null;
        CommonTree char_literal120_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "assign_op");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(197, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:197:11: ( ( AND | OR | NEG | BIT_AND | BIT_OR | BIT_NEG | BIT_XOR | BIT_SHL | BIT_SHR | MUL | DIV | MOD | PLUS | SURPLUS )? '=' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:197:13: ( AND | OR | NEG | BIT_AND | BIT_OR | BIT_NEG | BIT_XOR | BIT_SHL | BIT_SHR | MUL | DIV | MOD | PLUS | SURPLUS )? '='
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(197,13);
            // F:\\workspace\\ESA\\grammar\\C.g:197:13: ( AND | OR | NEG | BIT_AND | BIT_OR | BIT_NEG | BIT_XOR | BIT_SHL | BIT_SHR | MUL | DIV | MOD | PLUS | SURPLUS )?
            int alt50=2;
            try { dbg.enterSubRule(50);
            try { dbg.enterDecision(50);

            int LA50_0 = input.LA(1);

            if ( ((LA50_0>=AND && LA50_0<=SURPLUS)) ) {
                alt50=1;
            }
            } finally {dbg.exitDecision(50);}

            switch (alt50) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:
                    {
                    dbg.location(197,13);
                    set119=(Token)input.LT(1);
                    if ( (input.LA(1)>=AND && input.LA(1)<=SURPLUS) ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set119));
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;

            }
            } finally {dbg.exitSubRule(50);}

            dbg.location(197,99);
            char_literal120=(Token)match(input,52,FOLLOW_52_in_assign_op979); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal120_tree = (CommonTree)adaptor.create(char_literal120);
            adaptor.addChild(root_0, char_literal120_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("assign_op", 34);
        }
        dbg.location(197, 103);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "assign_op");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "assign_op"

    public static class conditional_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditional_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:199:1: conditional_expression : ( ( logical_or_expression '?' )=> logical_or_expression '?' logical_or_expression ':' conditional_expression | logical_or_expression );
    public final CParser.conditional_expression_return conditional_expression() throws RecognitionException {
    traceIn("conditional_expression", 35);
        CParser.conditional_expression_return retval = new CParser.conditional_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal122=null;
        Token char_literal124=null;
        CParser.logical_or_expression_return logical_or_expression121 = null;

        CParser.logical_or_expression_return logical_or_expression123 = null;

        CParser.conditional_expression_return conditional_expression125 = null;

        CParser.logical_or_expression_return logical_or_expression126 = null;


        CommonTree char_literal122_tree=null;
        CommonTree char_literal124_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "conditional_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(199, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:200:2: ( ( logical_or_expression '?' )=> logical_or_expression '?' logical_or_expression ':' conditional_expression | logical_or_expression )
            int alt51=2;
            try { dbg.enterDecision(51);

            try {
                isCyclicDecision = true;
                alt51 = dfa51.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(51);}

            switch (alt51) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:200:4: ( logical_or_expression '?' )=> logical_or_expression '?' logical_or_expression ':' conditional_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(200,34);
                    pushFollow(FOLLOW_logical_or_expression_in_conditional_expression996);
                    logical_or_expression121=logical_or_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, logical_or_expression121.getTree());
                    dbg.location(200,56);
                    char_literal122=(Token)match(input,77,FOLLOW_77_in_conditional_expression998); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal122_tree = (CommonTree)adaptor.create(char_literal122);
                    adaptor.addChild(root_0, char_literal122_tree);
                    }
                    dbg.location(200,60);
                    pushFollow(FOLLOW_logical_or_expression_in_conditional_expression1000);
                    logical_or_expression123=logical_or_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, logical_or_expression123.getTree());
                    dbg.location(200,82);
                    char_literal124=(Token)match(input,75,FOLLOW_75_in_conditional_expression1002); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal124_tree = (CommonTree)adaptor.create(char_literal124);
                    adaptor.addChild(root_0, char_literal124_tree);
                    }
                    dbg.location(200,86);
                    pushFollow(FOLLOW_conditional_expression_in_conditional_expression1004);
                    conditional_expression125=conditional_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditional_expression125.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:201:4: logical_or_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(201,4);
                    pushFollow(FOLLOW_logical_or_expression_in_conditional_expression1009);
                    logical_or_expression126=logical_or_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, logical_or_expression126.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("conditional_expression", 35);
        }
        dbg.location(202, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "conditional_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "conditional_expression"

    public static class logical_or_expression_return extends ParserRuleReturnScope {
        public boolean value;
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "logical_or_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:203:1: logical_or_expression returns [boolean value] : logical_and_expression ( OR logical_and_expression )* ;
    public final CParser.logical_or_expression_return logical_or_expression() throws RecognitionException {
    traceIn("logical_or_expression", 36);
        CParser.logical_or_expression_return retval = new CParser.logical_or_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token OR128=null;
        CParser.logical_and_expression_return logical_and_expression127 = null;

        CParser.logical_and_expression_return logical_and_expression129 = null;


        CommonTree OR128_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "logical_or_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(203, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:204:2: ( logical_and_expression ( OR logical_and_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:204:4: logical_and_expression ( OR logical_and_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(204,4);
            pushFollow(FOLLOW_logical_and_expression_in_logical_or_expression1023);
            logical_and_expression127=logical_and_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, logical_and_expression127.getTree());
            dbg.location(204,27);
            // F:\\workspace\\ESA\\grammar\\C.g:204:27: ( OR logical_and_expression )*
            try { dbg.enterSubRule(52);

            loop52:
            do {
                int alt52=2;
                try { dbg.enterDecision(52);

                int LA52_0 = input.LA(1);

                if ( (LA52_0==OR) ) {
                    alt52=1;
                }


                } finally {dbg.exitDecision(52);}

                switch (alt52) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:204:29: OR logical_and_expression
            	    {
            	    dbg.location(204,29);
            	    OR128=(Token)match(input,OR,FOLLOW_OR_in_logical_or_expression1027); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    OR128_tree = (CommonTree)adaptor.create(OR128);
            	    adaptor.addChild(root_0, OR128_tree);
            	    }
            	    dbg.location(204,32);
            	    pushFollow(FOLLOW_logical_and_expression_in_logical_or_expression1029);
            	    logical_and_expression129=logical_and_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, logical_and_expression129.getTree());

            	    }
            	    break;

            	default :
            	    break loop52;
                }
            } while (true);
            } finally {dbg.exitSubRule(52);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("logical_or_expression", 36);
        }
        dbg.location(205, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "logical_or_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "logical_or_expression"

    public static class logical_and_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "logical_and_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:206:1: logical_and_expression : inclusive_or_expression ( AND inclusive_or_expression )* ;
    public final CParser.logical_and_expression_return logical_and_expression() throws RecognitionException {
    traceIn("logical_and_expression", 37);
        CParser.logical_and_expression_return retval = new CParser.logical_and_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token AND131=null;
        CParser.inclusive_or_expression_return inclusive_or_expression130 = null;

        CParser.inclusive_or_expression_return inclusive_or_expression132 = null;


        CommonTree AND131_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "logical_and_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(206, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:207:2: ( inclusive_or_expression ( AND inclusive_or_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:207:4: inclusive_or_expression ( AND inclusive_or_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(207,4);
            pushFollow(FOLLOW_inclusive_or_expression_in_logical_and_expression1041);
            inclusive_or_expression130=inclusive_or_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, inclusive_or_expression130.getTree());
            dbg.location(207,28);
            // F:\\workspace\\ESA\\grammar\\C.g:207:28: ( AND inclusive_or_expression )*
            try { dbg.enterSubRule(53);

            loop53:
            do {
                int alt53=2;
                try { dbg.enterDecision(53);

                int LA53_0 = input.LA(1);

                if ( (LA53_0==AND) ) {
                    alt53=1;
                }


                } finally {dbg.exitDecision(53);}

                switch (alt53) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:207:29: AND inclusive_or_expression
            	    {
            	    dbg.location(207,29);
            	    AND131=(Token)match(input,AND,FOLLOW_AND_in_logical_and_expression1044); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    AND131_tree = (CommonTree)adaptor.create(AND131);
            	    adaptor.addChild(root_0, AND131_tree);
            	    }
            	    dbg.location(207,33);
            	    pushFollow(FOLLOW_inclusive_or_expression_in_logical_and_expression1046);
            	    inclusive_or_expression132=inclusive_or_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, inclusive_or_expression132.getTree());

            	    }
            	    break;

            	default :
            	    break loop53;
                }
            } while (true);
            } finally {dbg.exitSubRule(53);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("logical_and_expression", 37);
        }
        dbg.location(208, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "logical_and_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "logical_and_expression"

    public static class inclusive_or_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "inclusive_or_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:209:1: inclusive_or_expression : exclusive_or_expression ( BIT_OR exclusive_or_expression )* ;
    public final CParser.inclusive_or_expression_return inclusive_or_expression() throws RecognitionException {
    traceIn("inclusive_or_expression", 38);
        CParser.inclusive_or_expression_return retval = new CParser.inclusive_or_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token BIT_OR134=null;
        CParser.exclusive_or_expression_return exclusive_or_expression133 = null;

        CParser.exclusive_or_expression_return exclusive_or_expression135 = null;


        CommonTree BIT_OR134_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "inclusive_or_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(209, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:210:2: ( exclusive_or_expression ( BIT_OR exclusive_or_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:210:4: exclusive_or_expression ( BIT_OR exclusive_or_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(210,4);
            pushFollow(FOLLOW_exclusive_or_expression_in_inclusive_or_expression1058);
            exclusive_or_expression133=exclusive_or_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, exclusive_or_expression133.getTree());
            dbg.location(210,28);
            // F:\\workspace\\ESA\\grammar\\C.g:210:28: ( BIT_OR exclusive_or_expression )*
            try { dbg.enterSubRule(54);

            loop54:
            do {
                int alt54=2;
                try { dbg.enterDecision(54);

                int LA54_0 = input.LA(1);

                if ( (LA54_0==BIT_OR) ) {
                    alt54=1;
                }


                } finally {dbg.exitDecision(54);}

                switch (alt54) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:210:29: BIT_OR exclusive_or_expression
            	    {
            	    dbg.location(210,29);
            	    BIT_OR134=(Token)match(input,BIT_OR,FOLLOW_BIT_OR_in_inclusive_or_expression1061); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    BIT_OR134_tree = (CommonTree)adaptor.create(BIT_OR134);
            	    adaptor.addChild(root_0, BIT_OR134_tree);
            	    }
            	    dbg.location(210,36);
            	    pushFollow(FOLLOW_exclusive_or_expression_in_inclusive_or_expression1063);
            	    exclusive_or_expression135=exclusive_or_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, exclusive_or_expression135.getTree());

            	    }
            	    break;

            	default :
            	    break loop54;
                }
            } while (true);
            } finally {dbg.exitSubRule(54);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("inclusive_or_expression", 38);
        }
        dbg.location(211, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "inclusive_or_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "inclusive_or_expression"

    public static class exclusive_or_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "exclusive_or_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:212:1: exclusive_or_expression : and_expression ( BIT_XOR and_expression )* ;
    public final CParser.exclusive_or_expression_return exclusive_or_expression() throws RecognitionException {
    traceIn("exclusive_or_expression", 39);
        CParser.exclusive_or_expression_return retval = new CParser.exclusive_or_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token BIT_XOR137=null;
        CParser.and_expression_return and_expression136 = null;

        CParser.and_expression_return and_expression138 = null;


        CommonTree BIT_XOR137_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "exclusive_or_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(212, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:213:2: ( and_expression ( BIT_XOR and_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:213:4: and_expression ( BIT_XOR and_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(213,4);
            pushFollow(FOLLOW_and_expression_in_exclusive_or_expression1075);
            and_expression136=and_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, and_expression136.getTree());
            dbg.location(213,19);
            // F:\\workspace\\ESA\\grammar\\C.g:213:19: ( BIT_XOR and_expression )*
            try { dbg.enterSubRule(55);

            loop55:
            do {
                int alt55=2;
                try { dbg.enterDecision(55);

                int LA55_0 = input.LA(1);

                if ( (LA55_0==BIT_XOR) ) {
                    alt55=1;
                }


                } finally {dbg.exitDecision(55);}

                switch (alt55) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:213:20: BIT_XOR and_expression
            	    {
            	    dbg.location(213,20);
            	    BIT_XOR137=(Token)match(input,BIT_XOR,FOLLOW_BIT_XOR_in_exclusive_or_expression1078); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    BIT_XOR137_tree = (CommonTree)adaptor.create(BIT_XOR137);
            	    adaptor.addChild(root_0, BIT_XOR137_tree);
            	    }
            	    dbg.location(213,28);
            	    pushFollow(FOLLOW_and_expression_in_exclusive_or_expression1080);
            	    and_expression138=and_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, and_expression138.getTree());

            	    }
            	    break;

            	default :
            	    break loop55;
                }
            } while (true);
            } finally {dbg.exitSubRule(55);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("exclusive_or_expression", 39);
        }
        dbg.location(214, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "exclusive_or_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "exclusive_or_expression"

    public static class and_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "and_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:215:1: and_expression : equality_expression ( BIT_AND equality_expression )* ;
    public final CParser.and_expression_return and_expression() throws RecognitionException {
    traceIn("and_expression", 40);
        CParser.and_expression_return retval = new CParser.and_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token BIT_AND140=null;
        CParser.equality_expression_return equality_expression139 = null;

        CParser.equality_expression_return equality_expression141 = null;


        CommonTree BIT_AND140_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "and_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(215, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:216:2: ( equality_expression ( BIT_AND equality_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:216:4: equality_expression ( BIT_AND equality_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(216,4);
            pushFollow(FOLLOW_equality_expression_in_and_expression1092);
            equality_expression139=equality_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, equality_expression139.getTree());
            dbg.location(216,24);
            // F:\\workspace\\ESA\\grammar\\C.g:216:24: ( BIT_AND equality_expression )*
            try { dbg.enterSubRule(56);

            loop56:
            do {
                int alt56=2;
                try { dbg.enterDecision(56);

                int LA56_0 = input.LA(1);

                if ( (LA56_0==BIT_AND) ) {
                    alt56=1;
                }


                } finally {dbg.exitDecision(56);}

                switch (alt56) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:216:25: BIT_AND equality_expression
            	    {
            	    dbg.location(216,25);
            	    BIT_AND140=(Token)match(input,BIT_AND,FOLLOW_BIT_AND_in_and_expression1095); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    BIT_AND140_tree = (CommonTree)adaptor.create(BIT_AND140);
            	    adaptor.addChild(root_0, BIT_AND140_tree);
            	    }
            	    dbg.location(216,33);
            	    pushFollow(FOLLOW_equality_expression_in_and_expression1097);
            	    equality_expression141=equality_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, equality_expression141.getTree());

            	    }
            	    break;

            	default :
            	    break loop56;
                }
            } while (true);
            } finally {dbg.exitSubRule(56);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("and_expression", 40);
        }
        dbg.location(217, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "and_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "and_expression"

    public static class equality_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "equality_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:218:1: equality_expression : relational_expression ( ( '==' | '!=' ) relational_expression )* ;
    public final CParser.equality_expression_return equality_expression() throws RecognitionException {
    traceIn("equality_expression", 41);
        CParser.equality_expression_return retval = new CParser.equality_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set143=null;
        CParser.relational_expression_return relational_expression142 = null;

        CParser.relational_expression_return relational_expression144 = null;


        CommonTree set143_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "equality_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(218, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:219:2: ( relational_expression ( ( '==' | '!=' ) relational_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:219:4: relational_expression ( ( '==' | '!=' ) relational_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(219,4);
            pushFollow(FOLLOW_relational_expression_in_equality_expression1109);
            relational_expression142=relational_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, relational_expression142.getTree());
            dbg.location(219,26);
            // F:\\workspace\\ESA\\grammar\\C.g:219:26: ( ( '==' | '!=' ) relational_expression )*
            try { dbg.enterSubRule(57);

            loop57:
            do {
                int alt57=2;
                try { dbg.enterDecision(57);

                int LA57_0 = input.LA(1);

                if ( ((LA57_0>=78 && LA57_0<=79)) ) {
                    alt57=1;
                }


                } finally {dbg.exitDecision(57);}

                switch (alt57) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:219:27: ( '==' | '!=' ) relational_expression
            	    {
            	    dbg.location(219,27);
            	    set143=(Token)input.LT(1);
            	    if ( (input.LA(1)>=78 && input.LA(1)<=79) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set143));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(219,39);
            	    pushFollow(FOLLOW_relational_expression_in_equality_expression1118);
            	    relational_expression144=relational_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, relational_expression144.getTree());

            	    }
            	    break;

            	default :
            	    break loop57;
                }
            } while (true);
            } finally {dbg.exitSubRule(57);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("equality_expression", 41);
        }
        dbg.location(220, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "equality_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "equality_expression"

    public static class relational_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "relational_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:221:1: relational_expression : shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )* ;
    public final CParser.relational_expression_return relational_expression() throws RecognitionException {
    traceIn("relational_expression", 42);
        CParser.relational_expression_return retval = new CParser.relational_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set146=null;
        CParser.shift_expression_return shift_expression145 = null;

        CParser.shift_expression_return shift_expression147 = null;


        CommonTree set146_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "relational_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(221, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:222:2: ( shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:222:4: shift_expression ( ( '<' | '>' | '<=' | '>=' ) shift_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(222,4);
            pushFollow(FOLLOW_shift_expression_in_relational_expression1130);
            shift_expression145=shift_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, shift_expression145.getTree());
            dbg.location(222,21);
            // F:\\workspace\\ESA\\grammar\\C.g:222:21: ( ( '<' | '>' | '<=' | '>=' ) shift_expression )*
            try { dbg.enterSubRule(58);

            loop58:
            do {
                int alt58=2;
                try { dbg.enterDecision(58);

                int LA58_0 = input.LA(1);

                if ( ((LA58_0>=80 && LA58_0<=83)) ) {
                    alt58=1;
                }


                } finally {dbg.exitDecision(58);}

                switch (alt58) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:222:22: ( '<' | '>' | '<=' | '>=' ) shift_expression
            	    {
            	    dbg.location(222,22);
            	    set146=(Token)input.LT(1);
            	    if ( (input.LA(1)>=80 && input.LA(1)<=83) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set146));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(222,42);
            	    pushFollow(FOLLOW_shift_expression_in_relational_expression1143);
            	    shift_expression147=shift_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, shift_expression147.getTree());

            	    }
            	    break;

            	default :
            	    break loop58;
                }
            } while (true);
            } finally {dbg.exitSubRule(58);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("relational_expression", 42);
        }
        dbg.location(223, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "relational_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "relational_expression"

    public static class shift_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "shift_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:224:1: shift_expression : additive_expression ( ( BIT_SHL | BIT_SHR ) additive_expression )* ;
    public final CParser.shift_expression_return shift_expression() throws RecognitionException {
    traceIn("shift_expression", 43);
        CParser.shift_expression_return retval = new CParser.shift_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set149=null;
        CParser.additive_expression_return additive_expression148 = null;

        CParser.additive_expression_return additive_expression150 = null;


        CommonTree set149_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "shift_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(224, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:225:2: ( additive_expression ( ( BIT_SHL | BIT_SHR ) additive_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:225:4: additive_expression ( ( BIT_SHL | BIT_SHR ) additive_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(225,4);
            pushFollow(FOLLOW_additive_expression_in_shift_expression1155);
            additive_expression148=additive_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, additive_expression148.getTree());
            dbg.location(225,24);
            // F:\\workspace\\ESA\\grammar\\C.g:225:24: ( ( BIT_SHL | BIT_SHR ) additive_expression )*
            try { dbg.enterSubRule(59);

            loop59:
            do {
                int alt59=2;
                try { dbg.enterDecision(59);

                int LA59_0 = input.LA(1);

                if ( ((LA59_0>=BIT_SHL && LA59_0<=BIT_SHR)) ) {
                    alt59=1;
                }


                } finally {dbg.exitDecision(59);}

                switch (alt59) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:225:25: ( BIT_SHL | BIT_SHR ) additive_expression
            	    {
            	    dbg.location(225,25);
            	    set149=(Token)input.LT(1);
            	    if ( (input.LA(1)>=BIT_SHL && input.LA(1)<=BIT_SHR) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set149));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(225,43);
            	    pushFollow(FOLLOW_additive_expression_in_shift_expression1164);
            	    additive_expression150=additive_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, additive_expression150.getTree());

            	    }
            	    break;

            	default :
            	    break loop59;
                }
            } while (true);
            } finally {dbg.exitSubRule(59);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("shift_expression", 43);
        }
        dbg.location(226, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "shift_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "shift_expression"

    public static class additive_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "additive_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:227:1: additive_expression : ( multiplicative_expression ) ( ( PLUS | SURPLUS ) multiplicative_expression )* ;
    public final CParser.additive_expression_return additive_expression() throws RecognitionException {
    traceIn("additive_expression", 44);
        CParser.additive_expression_return retval = new CParser.additive_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set152=null;
        CParser.multiplicative_expression_return multiplicative_expression151 = null;

        CParser.multiplicative_expression_return multiplicative_expression153 = null;


        CommonTree set152_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "additive_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(227, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:228:2: ( ( multiplicative_expression ) ( ( PLUS | SURPLUS ) multiplicative_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:228:4: ( multiplicative_expression ) ( ( PLUS | SURPLUS ) multiplicative_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(228,4);
            // F:\\workspace\\ESA\\grammar\\C.g:228:4: ( multiplicative_expression )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:228:5: multiplicative_expression
            {
            dbg.location(228,5);
            pushFollow(FOLLOW_multiplicative_expression_in_additive_expression1177);
            multiplicative_expression151=multiplicative_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, multiplicative_expression151.getTree());

            }

            dbg.location(228,32);
            // F:\\workspace\\ESA\\grammar\\C.g:228:32: ( ( PLUS | SURPLUS ) multiplicative_expression )*
            try { dbg.enterSubRule(60);

            loop60:
            do {
                int alt60=2;
                try { dbg.enterDecision(60);

                int LA60_0 = input.LA(1);

                if ( ((LA60_0>=PLUS && LA60_0<=SURPLUS)) ) {
                    alt60=1;
                }


                } finally {dbg.exitDecision(60);}

                switch (alt60) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:228:33: ( PLUS | SURPLUS ) multiplicative_expression
            	    {
            	    dbg.location(228,33);
            	    set152=(Token)input.LT(1);
            	    if ( (input.LA(1)>=PLUS && input.LA(1)<=SURPLUS) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set152));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(228,48);
            	    pushFollow(FOLLOW_multiplicative_expression_in_additive_expression1187);
            	    multiplicative_expression153=multiplicative_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, multiplicative_expression153.getTree());

            	    }
            	    break;

            	default :
            	    break loop60;
                }
            } while (true);
            } finally {dbg.exitSubRule(60);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("additive_expression", 44);
        }
        dbg.location(229, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "additive_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "additive_expression"

    public static class multiplicative_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "multiplicative_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:230:1: multiplicative_expression : ( cast_expression ) ( ( MUL | DIV | MOD ) cast_expression )* ;
    public final CParser.multiplicative_expression_return multiplicative_expression() throws RecognitionException {
    traceIn("multiplicative_expression", 45);
        CParser.multiplicative_expression_return retval = new CParser.multiplicative_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set155=null;
        CParser.cast_expression_return cast_expression154 = null;

        CParser.cast_expression_return cast_expression156 = null;


        CommonTree set155_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "multiplicative_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(230, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:231:2: ( ( cast_expression ) ( ( MUL | DIV | MOD ) cast_expression )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:231:4: ( cast_expression ) ( ( MUL | DIV | MOD ) cast_expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(231,4);
            // F:\\workspace\\ESA\\grammar\\C.g:231:4: ( cast_expression )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:231:5: cast_expression
            {
            dbg.location(231,5);
            pushFollow(FOLLOW_cast_expression_in_multiplicative_expression1200);
            cast_expression154=cast_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, cast_expression154.getTree());

            }

            dbg.location(231,22);
            // F:\\workspace\\ESA\\grammar\\C.g:231:22: ( ( MUL | DIV | MOD ) cast_expression )*
            try { dbg.enterSubRule(61);

            loop61:
            do {
                int alt61=2;
                try { dbg.enterDecision(61);

                int LA61_0 = input.LA(1);

                if ( ((LA61_0>=MUL && LA61_0<=MOD)) ) {
                    alt61=1;
                }


                } finally {dbg.exitDecision(61);}

                switch (alt61) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:231:23: ( MUL | DIV | MOD ) cast_expression
            	    {
            	    dbg.location(231,23);
            	    set155=(Token)input.LT(1);
            	    if ( (input.LA(1)>=MUL && input.LA(1)<=MOD) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set155));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(231,37);
            	    pushFollow(FOLLOW_cast_expression_in_multiplicative_expression1212);
            	    cast_expression156=cast_expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, cast_expression156.getTree());

            	    }
            	    break;

            	default :
            	    break loop61;
                }
            } while (true);
            } finally {dbg.exitSubRule(61);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("multiplicative_expression", 45);
        }
        dbg.location(232, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "multiplicative_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "multiplicative_expression"

    public static class cast_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "cast_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:233:1: cast_expression : ( ( '(' specifiers )=> '(' type_name ')' cast_expression | unary_expression );
    public final CParser.cast_expression_return cast_expression() throws RecognitionException {
    traceIn("cast_expression", 46);
        CParser.cast_expression_return retval = new CParser.cast_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal157=null;
        Token char_literal159=null;
        CParser.type_name_return type_name158 = null;

        CParser.cast_expression_return cast_expression160 = null;

        CParser.unary_expression_return unary_expression161 = null;


        CommonTree char_literal157_tree=null;
        CommonTree char_literal159_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "cast_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(233, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:234:2: ( ( '(' specifiers )=> '(' type_name ')' cast_expression | unary_expression )
            int alt62=2;
            try { dbg.enterDecision(62);

            try {
                isCyclicDecision = true;
                alt62 = dfa62.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(62);}

            switch (alt62) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:234:4: ( '(' specifiers )=> '(' type_name ')' cast_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(234,23);
                    char_literal157=(Token)match(input,53,FOLLOW_53_in_cast_expression1231); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal157_tree = (CommonTree)adaptor.create(char_literal157);
                    adaptor.addChild(root_0, char_literal157_tree);
                    }
                    dbg.location(234,27);
                    pushFollow(FOLLOW_type_name_in_cast_expression1233);
                    type_name158=type_name();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type_name158.getTree());
                    dbg.location(234,37);
                    char_literal159=(Token)match(input,54,FOLLOW_54_in_cast_expression1235); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal159_tree = (CommonTree)adaptor.create(char_literal159);
                    adaptor.addChild(root_0, char_literal159_tree);
                    }
                    dbg.location(234,41);
                    pushFollow(FOLLOW_cast_expression_in_cast_expression1237);
                    cast_expression160=cast_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, cast_expression160.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:235:4: unary_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(235,4);
                    pushFollow(FOLLOW_unary_expression_in_cast_expression1242);
                    unary_expression161=unary_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unary_expression161.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("cast_expression", 46);
        }
        dbg.location(236, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "cast_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "cast_expression"

    public static class unary_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unary_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:237:1: unary_expression : ( prefix_expression | ( INC | DEC ) cast_expression | unary_operator cast_expression | 'sizeof' prefix_expression | ( 'sizeof' '(' specifiers )=> 'sizeof' '(' type_name ')' );
    public final CParser.unary_expression_return unary_expression() throws RecognitionException {
    traceIn("unary_expression", 47);
        CParser.unary_expression_return retval = new CParser.unary_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set163=null;
        Token string_literal167=null;
        Token string_literal169=null;
        Token char_literal170=null;
        Token char_literal172=null;
        CParser.prefix_expression_return prefix_expression162 = null;

        CParser.cast_expression_return cast_expression164 = null;

        CParser.unary_operator_return unary_operator165 = null;

        CParser.cast_expression_return cast_expression166 = null;

        CParser.prefix_expression_return prefix_expression168 = null;

        CParser.type_name_return type_name171 = null;


        CommonTree set163_tree=null;
        CommonTree string_literal167_tree=null;
        CommonTree string_literal169_tree=null;
        CommonTree char_literal170_tree=null;
        CommonTree char_literal172_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "unary_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(237, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:238:2: ( prefix_expression | ( INC | DEC ) cast_expression | unary_operator cast_expression | 'sizeof' prefix_expression | ( 'sizeof' '(' specifiers )=> 'sizeof' '(' type_name ')' )
            int alt63=5;
            try { dbg.enterDecision(63);

            try {
                isCyclicDecision = true;
                alt63 = dfa63.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(63);}

            switch (alt63) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:238:4: prefix_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(238,4);
                    pushFollow(FOLLOW_prefix_expression_in_unary_expression1252);
                    prefix_expression162=prefix_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, prefix_expression162.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:239:4: ( INC | DEC ) cast_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(239,4);
                    set163=(Token)input.LT(1);
                    if ( (input.LA(1)>=INC && input.LA(1)<=DEC) ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set163));
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }

                    dbg.location(239,14);
                    pushFollow(FOLLOW_cast_expression_in_unary_expression1263);
                    cast_expression164=cast_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, cast_expression164.getTree());

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:240:4: unary_operator cast_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(240,4);
                    pushFollow(FOLLOW_unary_operator_in_unary_expression1268);
                    unary_operator165=unary_operator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unary_operator165.getTree());
                    dbg.location(240,19);
                    pushFollow(FOLLOW_cast_expression_in_unary_expression1270);
                    cast_expression166=cast_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, cast_expression166.getTree());

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // F:\\workspace\\ESA\\grammar\\C.g:241:4: 'sizeof' prefix_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(241,4);
                    string_literal167=(Token)match(input,84,FOLLOW_84_in_unary_expression1275); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal167_tree = (CommonTree)adaptor.create(string_literal167);
                    adaptor.addChild(root_0, string_literal167_tree);
                    }
                    dbg.location(241,13);
                    pushFollow(FOLLOW_prefix_expression_in_unary_expression1277);
                    prefix_expression168=prefix_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, prefix_expression168.getTree());

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // F:\\workspace\\ESA\\grammar\\C.g:242:4: ( 'sizeof' '(' specifiers )=> 'sizeof' '(' type_name ')'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(242,32);
                    string_literal169=(Token)match(input,84,FOLLOW_84_in_unary_expression1291); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal169_tree = (CommonTree)adaptor.create(string_literal169);
                    adaptor.addChild(root_0, string_literal169_tree);
                    }
                    dbg.location(242,41);
                    char_literal170=(Token)match(input,53,FOLLOW_53_in_unary_expression1293); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal170_tree = (CommonTree)adaptor.create(char_literal170);
                    adaptor.addChild(root_0, char_literal170_tree);
                    }
                    dbg.location(242,45);
                    pushFollow(FOLLOW_type_name_in_unary_expression1295);
                    type_name171=type_name();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type_name171.getTree());
                    dbg.location(242,55);
                    char_literal172=(Token)match(input,54,FOLLOW_54_in_unary_expression1297); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal172_tree = (CommonTree)adaptor.create(char_literal172);
                    adaptor.addChild(root_0, char_literal172_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("unary_expression", 47);
        }
        dbg.location(243, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "unary_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "unary_expression"

    public static class unary_operator_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unary_operator"
    // F:\\workspace\\ESA\\grammar\\C.g:244:1: unary_operator : ( PLUS | SURPLUS | NEG | BIT_NEG );
    public final CParser.unary_operator_return unary_operator() throws RecognitionException {
    traceIn("unary_operator", 48);
        CParser.unary_operator_return retval = new CParser.unary_operator_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set173=null;

        CommonTree set173_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "unary_operator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(244, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:245:2: ( PLUS | SURPLUS | NEG | BIT_NEG )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(245,2);
            set173=(Token)input.LT(1);
            if ( input.LA(1)==NEG||input.LA(1)==BIT_NEG||(input.LA(1)>=PLUS && input.LA(1)<=SURPLUS) ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set173));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("unary_operator", 48);
        }
        dbg.location(245, 35);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "unary_operator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "unary_operator"

    public static class prefix_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "prefix_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:247:1: prefix_expression : ( '&' postfix_expression | '*' postfix_expression | postfix_expression );
    public final CParser.prefix_expression_return prefix_expression() throws RecognitionException {
    traceIn("prefix_expression", 49);
        CParser.prefix_expression_return retval = new CParser.prefix_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal174=null;
        Token char_literal176=null;
        CParser.postfix_expression_return postfix_expression175 = null;

        CParser.postfix_expression_return postfix_expression177 = null;

        CParser.postfix_expression_return postfix_expression178 = null;


        CommonTree char_literal174_tree=null;
        CommonTree char_literal176_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "prefix_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(247, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:248:2: ( '&' postfix_expression | '*' postfix_expression | postfix_expression )
            int alt64=3;
            try { dbg.enterDecision(64);

            switch ( input.LA(1) ) {
            case BIT_AND:
                {
                alt64=1;
                }
                break;
            case MUL:
                {
                alt64=2;
                }
                break;
            case IDENTIFIER:
            case HEX_LITERAL:
            case OCTAL_LITERAL:
            case DECIMAL_LITERAL:
            case FLOATING_POINT_LITERAL:
            case CHARACTER_LITERAL:
            case STRING_LITERAL:
            case 53:
                {
                alt64=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 64, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(64);}

            switch (alt64) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:248:4: '&' postfix_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(248,4);
                    char_literal174=(Token)match(input,BIT_AND,FOLLOW_BIT_AND_in_prefix_expression1329); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal174_tree = (CommonTree)adaptor.create(char_literal174);
                    adaptor.addChild(root_0, char_literal174_tree);
                    }
                    dbg.location(248,8);
                    pushFollow(FOLLOW_postfix_expression_in_prefix_expression1331);
                    postfix_expression175=postfix_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, postfix_expression175.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:249:4: '*' postfix_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(249,4);
                    char_literal176=(Token)match(input,MUL,FOLLOW_MUL_in_prefix_expression1336); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal176_tree = (CommonTree)adaptor.create(char_literal176);
                    adaptor.addChild(root_0, char_literal176_tree);
                    }
                    dbg.location(249,8);
                    pushFollow(FOLLOW_postfix_expression_in_prefix_expression1338);
                    postfix_expression177=postfix_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, postfix_expression177.getTree());

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:250:4: postfix_expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(250,4);
                    pushFollow(FOLLOW_postfix_expression_in_prefix_expression1343);
                    postfix_expression178=postfix_expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, postfix_expression178.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("prefix_expression", 49);
        }
        dbg.location(251, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "prefix_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "prefix_expression"

    public static class postfix_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "postfix_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:253:1: postfix_expression : primary_expression ( '[' expression ']' | '(' ( argument_expression_list )? ')' | '.' IDENTIFIER | '->' IDENTIFIER | INC | DEC )* ;
    public final CParser.postfix_expression_return postfix_expression() throws RecognitionException {
    traceIn("postfix_expression", 50);
        CParser.postfix_expression_return retval = new CParser.postfix_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal180=null;
        Token char_literal182=null;
        Token char_literal183=null;
        Token char_literal185=null;
        Token char_literal186=null;
        Token IDENTIFIER187=null;
        Token string_literal188=null;
        Token IDENTIFIER189=null;
        Token INC190=null;
        Token DEC191=null;
        CParser.primary_expression_return primary_expression179 = null;

        CParser.expression_return expression181 = null;

        CParser.argument_expression_list_return argument_expression_list184 = null;


        CommonTree char_literal180_tree=null;
        CommonTree char_literal182_tree=null;
        CommonTree char_literal183_tree=null;
        CommonTree char_literal185_tree=null;
        CommonTree char_literal186_tree=null;
        CommonTree IDENTIFIER187_tree=null;
        CommonTree string_literal188_tree=null;
        CommonTree IDENTIFIER189_tree=null;
        CommonTree INC190_tree=null;
        CommonTree DEC191_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "postfix_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(253, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:254:2: ( primary_expression ( '[' expression ']' | '(' ( argument_expression_list )? ')' | '.' IDENTIFIER | '->' IDENTIFIER | INC | DEC )* )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:254:6: primary_expression ( '[' expression ']' | '(' ( argument_expression_list )? ')' | '.' IDENTIFIER | '->' IDENTIFIER | INC | DEC )*
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(254,6);
            pushFollow(FOLLOW_primary_expression_in_postfix_expression1356);
            primary_expression179=primary_expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, primary_expression179.getTree());
            dbg.location(255,9);
            // F:\\workspace\\ESA\\grammar\\C.g:255:9: ( '[' expression ']' | '(' ( argument_expression_list )? ')' | '.' IDENTIFIER | '->' IDENTIFIER | INC | DEC )*
            try { dbg.enterSubRule(66);

            loop66:
            do {
                int alt66=7;
                try { dbg.enterDecision(66);

                switch ( input.LA(1) ) {
                case 55:
                    {
                    alt66=1;
                    }
                    break;
                case 53:
                    {
                    alt66=2;
                    }
                    break;
                case 85:
                    {
                    alt66=3;
                    }
                    break;
                case 86:
                    {
                    alt66=4;
                    }
                    break;
                case INC:
                    {
                    alt66=5;
                    }
                    break;
                case DEC:
                    {
                    alt66=6;
                    }
                    break;

                }

                } finally {dbg.exitDecision(66);}

                switch (alt66) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:255:13: '[' expression ']'
            	    {
            	    dbg.location(255,13);
            	    char_literal180=(Token)match(input,55,FOLLOW_55_in_postfix_expression1370); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal180_tree = (CommonTree)adaptor.create(char_literal180);
            	    adaptor.addChild(root_0, char_literal180_tree);
            	    }
            	    dbg.location(255,17);
            	    pushFollow(FOLLOW_expression_in_postfix_expression1372);
            	    expression181=expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression181.getTree());
            	    dbg.location(255,28);
            	    char_literal182=(Token)match(input,56,FOLLOW_56_in_postfix_expression1374); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal182_tree = (CommonTree)adaptor.create(char_literal182);
            	    adaptor.addChild(root_0, char_literal182_tree);
            	    }

            	    }
            	    break;
            	case 2 :
            	    dbg.enterAlt(2);

            	    // F:\\workspace\\ESA\\grammar\\C.g:256:7: '(' ( argument_expression_list )? ')'
            	    {
            	    dbg.location(256,7);
            	    char_literal183=(Token)match(input,53,FOLLOW_53_in_postfix_expression1382); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal183_tree = (CommonTree)adaptor.create(char_literal183);
            	    adaptor.addChild(root_0, char_literal183_tree);
            	    }
            	    dbg.location(256,11);
            	    // F:\\workspace\\ESA\\grammar\\C.g:256:11: ( argument_expression_list )?
            	    int alt65=2;
            	    try { dbg.enterSubRule(65);
            	    try { dbg.enterDecision(65);

            	    int LA65_0 = input.LA(1);

            	    if ( ((LA65_0>=IDENTIFIER && LA65_0<=DEC)||(LA65_0>=NEG && LA65_0<=BIT_AND)||LA65_0==BIT_NEG||LA65_0==MUL||(LA65_0>=PLUS && LA65_0<=STRING_LITERAL)||LA65_0==53||LA65_0==84) ) {
            	        alt65=1;
            	    }
            	    } finally {dbg.exitDecision(65);}

            	    switch (alt65) {
            	        case 1 :
            	            dbg.enterAlt(1);

            	            // F:\\workspace\\ESA\\grammar\\C.g:256:11: argument_expression_list
            	            {
            	            dbg.location(256,11);
            	            pushFollow(FOLLOW_argument_expression_list_in_postfix_expression1384);
            	            argument_expression_list184=argument_expression_list();

            	            state._fsp--;
            	            if (state.failed) return retval;
            	            if ( state.backtracking==0 ) adaptor.addChild(root_0, argument_expression_list184.getTree());

            	            }
            	            break;

            	    }
            	    } finally {dbg.exitSubRule(65);}

            	    dbg.location(256,37);
            	    char_literal185=(Token)match(input,54,FOLLOW_54_in_postfix_expression1387); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal185_tree = (CommonTree)adaptor.create(char_literal185);
            	    adaptor.addChild(root_0, char_literal185_tree);
            	    }

            	    }
            	    break;
            	case 3 :
            	    dbg.enterAlt(3);

            	    // F:\\workspace\\ESA\\grammar\\C.g:257:7: '.' IDENTIFIER
            	    {
            	    dbg.location(257,7);
            	    char_literal186=(Token)match(input,85,FOLLOW_85_in_postfix_expression1395); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal186_tree = (CommonTree)adaptor.create(char_literal186);
            	    adaptor.addChild(root_0, char_literal186_tree);
            	    }
            	    dbg.location(257,11);
            	    IDENTIFIER187=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_postfix_expression1397); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    IDENTIFIER187_tree = (CommonTree)adaptor.create(IDENTIFIER187);
            	    adaptor.addChild(root_0, IDENTIFIER187_tree);
            	    }

            	    }
            	    break;
            	case 4 :
            	    dbg.enterAlt(4);

            	    // F:\\workspace\\ESA\\grammar\\C.g:258:7: '->' IDENTIFIER
            	    {
            	    dbg.location(258,7);
            	    string_literal188=(Token)match(input,86,FOLLOW_86_in_postfix_expression1405); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal188_tree = (CommonTree)adaptor.create(string_literal188);
            	    adaptor.addChild(root_0, string_literal188_tree);
            	    }
            	    dbg.location(258,12);
            	    IDENTIFIER189=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_postfix_expression1407); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    IDENTIFIER189_tree = (CommonTree)adaptor.create(IDENTIFIER189);
            	    adaptor.addChild(root_0, IDENTIFIER189_tree);
            	    }

            	    }
            	    break;
            	case 5 :
            	    dbg.enterAlt(5);

            	    // F:\\workspace\\ESA\\grammar\\C.g:259:7: INC
            	    {
            	    dbg.location(259,7);
            	    INC190=(Token)match(input,INC,FOLLOW_INC_in_postfix_expression1415); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    INC190_tree = (CommonTree)adaptor.create(INC190);
            	    adaptor.addChild(root_0, INC190_tree);
            	    }

            	    }
            	    break;
            	case 6 :
            	    dbg.enterAlt(6);

            	    // F:\\workspace\\ESA\\grammar\\C.g:259:11: DEC
            	    {
            	    dbg.location(259,11);
            	    DEC191=(Token)match(input,DEC,FOLLOW_DEC_in_postfix_expression1417); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    DEC191_tree = (CommonTree)adaptor.create(DEC191);
            	    adaptor.addChild(root_0, DEC191_tree);
            	    }

            	    }
            	    break;

            	default :
            	    break loop66;
                }
            } while (true);
            } finally {dbg.exitSubRule(66);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("postfix_expression", 50);
        }
        dbg.location(261, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "postfix_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "postfix_expression"

    public static class primary_expression_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "primary_expression"
    // F:\\workspace\\ESA\\grammar\\C.g:263:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );
    public final CParser.primary_expression_return primary_expression() throws RecognitionException {
    traceIn("primary_expression", 51);
        CParser.primary_expression_return retval = new CParser.primary_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENTIFIER192=null;
        Token char_literal194=null;
        Token char_literal196=null;
        CParser.constant_return constant193 = null;

        CParser.expression_return expression195 = null;


        CommonTree IDENTIFIER192_tree=null;
        CommonTree char_literal194_tree=null;
        CommonTree char_literal196_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "primary_expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(263, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:264:2: ( IDENTIFIER | constant | '(' expression ')' )
            int alt67=3;
            try { dbg.enterDecision(67);

            switch ( input.LA(1) ) {
            case IDENTIFIER:
                {
                alt67=1;
                }
                break;
            case HEX_LITERAL:
            case OCTAL_LITERAL:
            case DECIMAL_LITERAL:
            case FLOATING_POINT_LITERAL:
            case CHARACTER_LITERAL:
            case STRING_LITERAL:
                {
                alt67=2;
                }
                break;
            case 53:
                {
                alt67=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 67, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(67);}

            switch (alt67) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:264:4: IDENTIFIER
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(264,4);
                    IDENTIFIER192=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary_expression1439); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER192_tree = (CommonTree)adaptor.create(IDENTIFIER192);
                    adaptor.addChild(root_0, IDENTIFIER192_tree);
                    }

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:265:4: constant
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(265,4);
                    pushFollow(FOLLOW_constant_in_primary_expression1444);
                    constant193=constant();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, constant193.getTree());

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:266:4: '(' expression ')'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(266,4);
                    char_literal194=(Token)match(input,53,FOLLOW_53_in_primary_expression1449); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal194_tree = (CommonTree)adaptor.create(char_literal194);
                    adaptor.addChild(root_0, char_literal194_tree);
                    }
                    dbg.location(266,8);
                    pushFollow(FOLLOW_expression_in_primary_expression1451);
                    expression195=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression195.getTree());
                    dbg.location(266,19);
                    char_literal196=(Token)match(input,54,FOLLOW_54_in_primary_expression1453); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal196_tree = (CommonTree)adaptor.create(char_literal196);
                    adaptor.addChild(root_0, char_literal196_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("primary_expression", 51);
        }
        dbg.location(267, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "primary_expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "primary_expression"

    public static class constant_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "constant"
    // F:\\workspace\\ESA\\grammar\\C.g:268:1: constant : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | FLOATING_POINT_LITERAL | CHARACTER_LITERAL | STRING_LITERAL );
    public final CParser.constant_return constant() throws RecognitionException {
    traceIn("constant", 52);
        CParser.constant_return retval = new CParser.constant_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token set197=null;

        CommonTree set197_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "constant");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(268, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:269:5: ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | FLOATING_POINT_LITERAL | CHARACTER_LITERAL | STRING_LITERAL )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(269,5);
            set197=(Token)input.LT(1);
            if ( (input.LA(1)>=HEX_LITERAL && input.LA(1)<=STRING_LITERAL) ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set197));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("constant", 52);
        }
        dbg.location(275, 5);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "constant");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "constant"

    public static class statement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statement"
    // F:\\workspace\\ESA\\grammar\\C.g:282:1: statement : ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement );
    public final CParser.statement_return statement() throws RecognitionException {
    traceIn("statement", 53);
        CParser.statement_return retval = new CParser.statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.labeled_statement_return labeled_statement198 = null;

        CParser.compound_statement_return compound_statement199 = null;

        CParser.expression_statement_return expression_statement200 = null;

        CParser.selection_statement_return selection_statement201 = null;

        CParser.iteration_statement_return iteration_statement202 = null;

        CParser.jump_statement_return jump_statement203 = null;



        try { dbg.enterRule(getGrammarFileName(), "statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(282, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:283:2: ( labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement )
            int alt68=6;
            try { dbg.enterDecision(68);

            switch ( input.LA(1) ) {
            case IDENTIFIER:
                {
                int LA68_1 = input.LA(2);

                if ( (LA68_1==75) ) {
                    alt68=1;
                }
                else if ( ((LA68_1>=INC && LA68_1<=SURPLUS)||LA68_1==50||(LA68_1>=52 && LA68_1<=53)||LA68_1==55||(LA68_1>=77 && LA68_1<=83)||(LA68_1>=85 && LA68_1<=86)) ) {
                    alt68=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 68, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                }
                break;
            case 87:
            case 88:
                {
                alt68=1;
                }
                break;
            case 47:
                {
                alt68=2;
                }
                break;
            case INC:
            case DEC:
            case NEG:
            case BIT_AND:
            case BIT_NEG:
            case MUL:
            case PLUS:
            case SURPLUS:
            case HEX_LITERAL:
            case OCTAL_LITERAL:
            case DECIMAL_LITERAL:
            case FLOATING_POINT_LITERAL:
            case CHARACTER_LITERAL:
            case STRING_LITERAL:
            case 50:
            case 53:
            case 84:
                {
                alt68=3;
                }
                break;
            case 89:
            case 91:
                {
                alt68=4;
                }
                break;
            case 92:
            case 93:
            case 94:
                {
                alt68=5;
                }
                break;
            case 95:
            case 96:
            case 97:
            case 98:
                {
                alt68=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 68, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(68);}

            switch (alt68) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:283:4: labeled_statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(283,4);
                    pushFollow(FOLLOW_labeled_statement_in_statement1530);
                    labeled_statement198=labeled_statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, labeled_statement198.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:284:4: compound_statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(284,4);
                    pushFollow(FOLLOW_compound_statement_in_statement1535);
                    compound_statement199=compound_statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, compound_statement199.getTree());

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:285:4: expression_statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(285,4);
                    pushFollow(FOLLOW_expression_statement_in_statement1540);
                    expression_statement200=expression_statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression_statement200.getTree());

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // F:\\workspace\\ESA\\grammar\\C.g:286:4: selection_statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(286,4);
                    pushFollow(FOLLOW_selection_statement_in_statement1545);
                    selection_statement201=selection_statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, selection_statement201.getTree());

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // F:\\workspace\\ESA\\grammar\\C.g:287:4: iteration_statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(287,4);
                    pushFollow(FOLLOW_iteration_statement_in_statement1550);
                    iteration_statement202=iteration_statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, iteration_statement202.getTree());

                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // F:\\workspace\\ESA\\grammar\\C.g:288:4: jump_statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(288,4);
                    pushFollow(FOLLOW_jump_statement_in_statement1555);
                    jump_statement203=jump_statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, jump_statement203.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("statement", 53);
        }
        dbg.location(289, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "statement"

    public static class labeled_statement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "labeled_statement"
    // F:\\workspace\\ESA\\grammar\\C.g:291:1: labeled_statement : ( IDENTIFIER ':' statement | 'case' expression ':' statement | 'default' ':' statement );
    public final CParser.labeled_statement_return labeled_statement() throws RecognitionException {
    traceIn("labeled_statement", 54);
        CParser.labeled_statement_return retval = new CParser.labeled_statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token IDENTIFIER204=null;
        Token char_literal205=null;
        Token string_literal207=null;
        Token char_literal209=null;
        Token string_literal211=null;
        Token char_literal212=null;
        CParser.statement_return statement206 = null;

        CParser.expression_return expression208 = null;

        CParser.statement_return statement210 = null;

        CParser.statement_return statement213 = null;


        CommonTree IDENTIFIER204_tree=null;
        CommonTree char_literal205_tree=null;
        CommonTree string_literal207_tree=null;
        CommonTree char_literal209_tree=null;
        CommonTree string_literal211_tree=null;
        CommonTree char_literal212_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "labeled_statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(291, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:292:2: ( IDENTIFIER ':' statement | 'case' expression ':' statement | 'default' ':' statement )
            int alt69=3;
            try { dbg.enterDecision(69);

            switch ( input.LA(1) ) {
            case IDENTIFIER:
                {
                alt69=1;
                }
                break;
            case 87:
                {
                alt69=2;
                }
                break;
            case 88:
                {
                alt69=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 69, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(69);}

            switch (alt69) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:292:4: IDENTIFIER ':' statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(292,4);
                    IDENTIFIER204=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_labeled_statement1566); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER204_tree = (CommonTree)adaptor.create(IDENTIFIER204);
                    adaptor.addChild(root_0, IDENTIFIER204_tree);
                    }
                    dbg.location(292,15);
                    char_literal205=(Token)match(input,75,FOLLOW_75_in_labeled_statement1568); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal205_tree = (CommonTree)adaptor.create(char_literal205);
                    adaptor.addChild(root_0, char_literal205_tree);
                    }
                    dbg.location(292,19);
                    pushFollow(FOLLOW_statement_in_labeled_statement1570);
                    statement206=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement206.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:293:4: 'case' expression ':' statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(293,4);
                    string_literal207=(Token)match(input,87,FOLLOW_87_in_labeled_statement1575); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal207_tree = (CommonTree)adaptor.create(string_literal207);
                    adaptor.addChild(root_0, string_literal207_tree);
                    }
                    dbg.location(293,11);
                    pushFollow(FOLLOW_expression_in_labeled_statement1577);
                    expression208=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression208.getTree());
                    dbg.location(293,22);
                    char_literal209=(Token)match(input,75,FOLLOW_75_in_labeled_statement1579); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal209_tree = (CommonTree)adaptor.create(char_literal209);
                    adaptor.addChild(root_0, char_literal209_tree);
                    }
                    dbg.location(293,26);
                    pushFollow(FOLLOW_statement_in_labeled_statement1581);
                    statement210=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement210.getTree());

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:294:4: 'default' ':' statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(294,4);
                    string_literal211=(Token)match(input,88,FOLLOW_88_in_labeled_statement1586); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal211_tree = (CommonTree)adaptor.create(string_literal211);
                    adaptor.addChild(root_0, string_literal211_tree);
                    }
                    dbg.location(294,14);
                    char_literal212=(Token)match(input,75,FOLLOW_75_in_labeled_statement1588); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal212_tree = (CommonTree)adaptor.create(char_literal212);
                    adaptor.addChild(root_0, char_literal212_tree);
                    }
                    dbg.location(294,18);
                    pushFollow(FOLLOW_statement_in_labeled_statement1590);
                    statement213=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement213.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("labeled_statement", 54);
        }
        dbg.location(295, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "labeled_statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "labeled_statement"

    public static class compound_statement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "compound_statement"
    // F:\\workspace\\ESA\\grammar\\C.g:297:1: compound_statement : '{' ( declaration )* ( statement_list )? '}' ;
    public final CParser.compound_statement_return compound_statement() throws RecognitionException {
    traceIn("compound_statement", 55);
        Scope2_stack.push(new Scope2_scope());

        CParser.compound_statement_return retval = new CParser.compound_statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal214=null;
        Token char_literal217=null;
        CParser.declaration_return declaration215 = null;

        CParser.statement_list_return statement_list216 = null;


        CommonTree char_literal214_tree=null;
        CommonTree char_literal217_tree=null;

         // 3 lookup tables
          ((Scope2_scope)Scope2_stack.peek()).types = new HashSet<String>(); // global shared variable/function declaration, typedef

        try { dbg.enterRule(getGrammarFileName(), "compound_statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(297, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:300:3: ( '{' ( declaration )* ( statement_list )? '}' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:300:5: '{' ( declaration )* ( statement_list )? '}'
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(300,5);
            char_literal214=(Token)match(input,47,FOLLOW_47_in_compound_statement1610); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal214_tree = (CommonTree)adaptor.create(char_literal214);
            adaptor.addChild(root_0, char_literal214_tree);
            }
            dbg.location(300,9);
            // F:\\workspace\\ESA\\grammar\\C.g:300:9: ( declaration )*
            try { dbg.enterSubRule(70);

            loop70:
            do {
                int alt70=2;
                try { dbg.enterDecision(70);

                try {
                    isCyclicDecision = true;
                    alt70 = dfa70.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(70);}

                switch (alt70) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:300:9: declaration
            	    {
            	    dbg.location(300,9);
            	    pushFollow(FOLLOW_declaration_in_compound_statement1612);
            	    declaration215=declaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, declaration215.getTree());

            	    }
            	    break;

            	default :
            	    break loop70;
                }
            } while (true);
            } finally {dbg.exitSubRule(70);}

            dbg.location(300,22);
            // F:\\workspace\\ESA\\grammar\\C.g:300:22: ( statement_list )?
            int alt71=2;
            try { dbg.enterSubRule(71);
            try { dbg.enterDecision(71);

            int LA71_0 = input.LA(1);

            if ( ((LA71_0>=IDENTIFIER && LA71_0<=DEC)||(LA71_0>=NEG && LA71_0<=BIT_AND)||LA71_0==BIT_NEG||LA71_0==MUL||(LA71_0>=PLUS && LA71_0<=STRING_LITERAL)||LA71_0==47||LA71_0==50||LA71_0==53||LA71_0==84||(LA71_0>=87 && LA71_0<=89)||(LA71_0>=91 && LA71_0<=98)) ) {
                alt71=1;
            }
            } finally {dbg.exitDecision(71);}

            switch (alt71) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:300:22: statement_list
                    {
                    dbg.location(300,22);
                    pushFollow(FOLLOW_statement_list_in_compound_statement1615);
                    statement_list216=statement_list();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement_list216.getTree());

                    }
                    break;

            }
            } finally {dbg.exitSubRule(71);}

            dbg.location(300,38);
            char_literal217=(Token)match(input,48,FOLLOW_48_in_compound_statement1618); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal217_tree = (CommonTree)adaptor.create(char_literal217);
            adaptor.addChild(root_0, char_literal217_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("compound_statement", 55);
            Scope2_stack.pop();

        }
        dbg.location(301, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "compound_statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "compound_statement"

    public static class statement_list_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statement_list"
    // F:\\workspace\\ESA\\grammar\\C.g:303:1: statement_list : ( statement )+ ;
    public final CParser.statement_list_return statement_list() throws RecognitionException {
    traceIn("statement_list", 56);
        CParser.statement_list_return retval = new CParser.statement_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CParser.statement_return statement218 = null;



        try { dbg.enterRule(getGrammarFileName(), "statement_list");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(303, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:304:2: ( ( statement )+ )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:304:4: ( statement )+
            {
            root_0 = (CommonTree)adaptor.nil();

            dbg.location(304,4);
            // F:\\workspace\\ESA\\grammar\\C.g:304:4: ( statement )+
            int cnt72=0;
            try { dbg.enterSubRule(72);

            loop72:
            do {
                int alt72=2;
                try { dbg.enterDecision(72);

                int LA72_0 = input.LA(1);

                if ( ((LA72_0>=IDENTIFIER && LA72_0<=DEC)||(LA72_0>=NEG && LA72_0<=BIT_AND)||LA72_0==BIT_NEG||LA72_0==MUL||(LA72_0>=PLUS && LA72_0<=STRING_LITERAL)||LA72_0==47||LA72_0==50||LA72_0==53||LA72_0==84||(LA72_0>=87 && LA72_0<=89)||(LA72_0>=91 && LA72_0<=98)) ) {
                    alt72=1;
                }


                } finally {dbg.exitDecision(72);}

                switch (alt72) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // F:\\workspace\\ESA\\grammar\\C.g:304:4: statement
            	    {
            	    dbg.location(304,4);
            	    pushFollow(FOLLOW_statement_in_statement_list1629);
            	    statement218=statement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement218.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt72 >= 1 ) break loop72;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(72, input);
                        dbg.recognitionException(eee);

                        throw eee;
                }
                cnt72++;
            } while (true);
            } finally {dbg.exitSubRule(72);}


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("statement_list", 56);
        }
        dbg.location(305, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "statement_list");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "statement_list"

    public static class expression_statement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expression_statement"
    // F:\\workspace\\ESA\\grammar\\C.g:307:1: expression_statement : ( ';' | expression ';' );
    public final CParser.expression_statement_return expression_statement() throws RecognitionException {
    traceIn("expression_statement", 57);
        CParser.expression_statement_return retval = new CParser.expression_statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal219=null;
        Token char_literal221=null;
        CParser.expression_return expression220 = null;


        CommonTree char_literal219_tree=null;
        CommonTree char_literal221_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "expression_statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(307, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:308:2: ( ';' | expression ';' )
            int alt73=2;
            try { dbg.enterDecision(73);

            int LA73_0 = input.LA(1);

            if ( (LA73_0==50) ) {
                alt73=1;
            }
            else if ( ((LA73_0>=IDENTIFIER && LA73_0<=DEC)||(LA73_0>=NEG && LA73_0<=BIT_AND)||LA73_0==BIT_NEG||LA73_0==MUL||(LA73_0>=PLUS && LA73_0<=STRING_LITERAL)||LA73_0==53||LA73_0==84) ) {
                alt73=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 73, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(73);}

            switch (alt73) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:308:4: ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(308,4);
                    char_literal219=(Token)match(input,50,FOLLOW_50_in_expression_statement1641); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal219_tree = (CommonTree)adaptor.create(char_literal219);
                    adaptor.addChild(root_0, char_literal219_tree);
                    }

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:309:4: expression ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(309,4);
                    pushFollow(FOLLOW_expression_in_expression_statement1646);
                    expression220=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression220.getTree());
                    dbg.location(309,15);
                    char_literal221=(Token)match(input,50,FOLLOW_50_in_expression_statement1648); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal221_tree = (CommonTree)adaptor.create(char_literal221);
                    adaptor.addChild(root_0, char_literal221_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("expression_statement", 57);
        }
        dbg.location(310, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expression_statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "expression_statement"

    public static class selection_statement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "selection_statement"
    // F:\\workspace\\ESA\\grammar\\C.g:312:1: selection_statement options {backtrack=true; } : ( 'if' '(' expression ')' statement ( 'else' statement ) | 'if' '(' expression ')' statement | 'switch' '(' expression ')' statement );
    public final CParser.selection_statement_return selection_statement() throws RecognitionException {
    traceIn("selection_statement", 58);
        CParser.selection_statement_return retval = new CParser.selection_statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal222=null;
        Token char_literal223=null;
        Token char_literal225=null;
        Token string_literal227=null;
        Token string_literal229=null;
        Token char_literal230=null;
        Token char_literal232=null;
        Token string_literal234=null;
        Token char_literal235=null;
        Token char_literal237=null;
        CParser.expression_return expression224 = null;

        CParser.statement_return statement226 = null;

        CParser.statement_return statement228 = null;

        CParser.expression_return expression231 = null;

        CParser.statement_return statement233 = null;

        CParser.expression_return expression236 = null;

        CParser.statement_return statement238 = null;


        CommonTree string_literal222_tree=null;
        CommonTree char_literal223_tree=null;
        CommonTree char_literal225_tree=null;
        CommonTree string_literal227_tree=null;
        CommonTree string_literal229_tree=null;
        CommonTree char_literal230_tree=null;
        CommonTree char_literal232_tree=null;
        CommonTree string_literal234_tree=null;
        CommonTree char_literal235_tree=null;
        CommonTree char_literal237_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "selection_statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(312, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:313:2: ( 'if' '(' expression ')' statement ( 'else' statement ) | 'if' '(' expression ')' statement | 'switch' '(' expression ')' statement )
            int alt74=3;
            try { dbg.enterDecision(74);

            int LA74_0 = input.LA(1);

            if ( (LA74_0==89) ) {
                int LA74_1 = input.LA(2);

                if ( (synpred7_C()) ) {
                    alt74=1;
                }
                else if ( (synpred8_C()) ) {
                    alt74=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 74, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else if ( (LA74_0==91) ) {
                alt74=3;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 74, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(74);}

            switch (alt74) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:313:4: 'if' '(' expression ')' statement ( 'else' statement )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(313,4);
                    string_literal222=(Token)match(input,89,FOLLOW_89_in_selection_statement1667); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal222_tree = (CommonTree)adaptor.create(string_literal222);
                    adaptor.addChild(root_0, string_literal222_tree);
                    }
                    dbg.location(313,9);
                    char_literal223=(Token)match(input,53,FOLLOW_53_in_selection_statement1669); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal223_tree = (CommonTree)adaptor.create(char_literal223);
                    adaptor.addChild(root_0, char_literal223_tree);
                    }
                    dbg.location(313,13);
                    pushFollow(FOLLOW_expression_in_selection_statement1671);
                    expression224=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression224.getTree());
                    dbg.location(313,24);
                    char_literal225=(Token)match(input,54,FOLLOW_54_in_selection_statement1673); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal225_tree = (CommonTree)adaptor.create(char_literal225);
                    adaptor.addChild(root_0, char_literal225_tree);
                    }
                    dbg.location(313,28);
                    pushFollow(FOLLOW_statement_in_selection_statement1675);
                    statement226=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement226.getTree());
                    dbg.location(313,38);
                    // F:\\workspace\\ESA\\grammar\\C.g:313:38: ( 'else' statement )
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:313:39: 'else' statement
                    {
                    dbg.location(313,39);
                    string_literal227=(Token)match(input,90,FOLLOW_90_in_selection_statement1678); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal227_tree = (CommonTree)adaptor.create(string_literal227);
                    adaptor.addChild(root_0, string_literal227_tree);
                    }
                    dbg.location(313,46);
                    pushFollow(FOLLOW_statement_in_selection_statement1680);
                    statement228=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement228.getTree());

                    }


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:314:4: 'if' '(' expression ')' statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(314,4);
                    string_literal229=(Token)match(input,89,FOLLOW_89_in_selection_statement1686); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal229_tree = (CommonTree)adaptor.create(string_literal229);
                    adaptor.addChild(root_0, string_literal229_tree);
                    }
                    dbg.location(314,9);
                    char_literal230=(Token)match(input,53,FOLLOW_53_in_selection_statement1688); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal230_tree = (CommonTree)adaptor.create(char_literal230);
                    adaptor.addChild(root_0, char_literal230_tree);
                    }
                    dbg.location(314,13);
                    pushFollow(FOLLOW_expression_in_selection_statement1690);
                    expression231=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression231.getTree());
                    dbg.location(314,24);
                    char_literal232=(Token)match(input,54,FOLLOW_54_in_selection_statement1692); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal232_tree = (CommonTree)adaptor.create(char_literal232);
                    adaptor.addChild(root_0, char_literal232_tree);
                    }
                    dbg.location(314,28);
                    pushFollow(FOLLOW_statement_in_selection_statement1694);
                    statement233=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement233.getTree());

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:315:4: 'switch' '(' expression ')' statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(315,4);
                    string_literal234=(Token)match(input,91,FOLLOW_91_in_selection_statement1699); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal234_tree = (CommonTree)adaptor.create(string_literal234);
                    adaptor.addChild(root_0, string_literal234_tree);
                    }
                    dbg.location(315,13);
                    char_literal235=(Token)match(input,53,FOLLOW_53_in_selection_statement1701); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal235_tree = (CommonTree)adaptor.create(char_literal235);
                    adaptor.addChild(root_0, char_literal235_tree);
                    }
                    dbg.location(315,17);
                    pushFollow(FOLLOW_expression_in_selection_statement1703);
                    expression236=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression236.getTree());
                    dbg.location(315,28);
                    char_literal237=(Token)match(input,54,FOLLOW_54_in_selection_statement1705); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal237_tree = (CommonTree)adaptor.create(char_literal237);
                    adaptor.addChild(root_0, char_literal237_tree);
                    }
                    dbg.location(315,32);
                    pushFollow(FOLLOW_statement_in_selection_statement1707);
                    statement238=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement238.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("selection_statement", 58);
        }
        dbg.location(316, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "selection_statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "selection_statement"

    public static class iteration_statement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "iteration_statement"
    // F:\\workspace\\ESA\\grammar\\C.g:318:1: iteration_statement : ( 'while' '(' expression ')' statement | 'do' statement 'while' '(' expression ')' ';' | 'for' '(' expression ';' expression ';' ( expression )? ')' statement );
    public final CParser.iteration_statement_return iteration_statement() throws RecognitionException {
    traceIn("iteration_statement", 59);
        CParser.iteration_statement_return retval = new CParser.iteration_statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal239=null;
        Token char_literal240=null;
        Token char_literal242=null;
        Token string_literal244=null;
        Token string_literal246=null;
        Token char_literal247=null;
        Token char_literal249=null;
        Token char_literal250=null;
        Token string_literal251=null;
        Token char_literal252=null;
        Token char_literal254=null;
        Token char_literal256=null;
        Token char_literal258=null;
        CParser.expression_return expression241 = null;

        CParser.statement_return statement243 = null;

        CParser.statement_return statement245 = null;

        CParser.expression_return expression248 = null;

        CParser.expression_return expression253 = null;

        CParser.expression_return expression255 = null;

        CParser.expression_return expression257 = null;

        CParser.statement_return statement259 = null;


        CommonTree string_literal239_tree=null;
        CommonTree char_literal240_tree=null;
        CommonTree char_literal242_tree=null;
        CommonTree string_literal244_tree=null;
        CommonTree string_literal246_tree=null;
        CommonTree char_literal247_tree=null;
        CommonTree char_literal249_tree=null;
        CommonTree char_literal250_tree=null;
        CommonTree string_literal251_tree=null;
        CommonTree char_literal252_tree=null;
        CommonTree char_literal254_tree=null;
        CommonTree char_literal256_tree=null;
        CommonTree char_literal258_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "iteration_statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(318, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:319:2: ( 'while' '(' expression ')' statement | 'do' statement 'while' '(' expression ')' ';' | 'for' '(' expression ';' expression ';' ( expression )? ')' statement )
            int alt76=3;
            try { dbg.enterDecision(76);

            switch ( input.LA(1) ) {
            case 92:
                {
                alt76=1;
                }
                break;
            case 93:
                {
                alt76=2;
                }
                break;
            case 94:
                {
                alt76=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 76, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(76);}

            switch (alt76) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:319:4: 'while' '(' expression ')' statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(319,4);
                    string_literal239=(Token)match(input,92,FOLLOW_92_in_iteration_statement1718); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal239_tree = (CommonTree)adaptor.create(string_literal239);
                    adaptor.addChild(root_0, string_literal239_tree);
                    }
                    dbg.location(319,12);
                    char_literal240=(Token)match(input,53,FOLLOW_53_in_iteration_statement1720); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal240_tree = (CommonTree)adaptor.create(char_literal240);
                    adaptor.addChild(root_0, char_literal240_tree);
                    }
                    dbg.location(319,16);
                    pushFollow(FOLLOW_expression_in_iteration_statement1722);
                    expression241=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression241.getTree());
                    dbg.location(319,27);
                    char_literal242=(Token)match(input,54,FOLLOW_54_in_iteration_statement1724); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal242_tree = (CommonTree)adaptor.create(char_literal242);
                    adaptor.addChild(root_0, char_literal242_tree);
                    }
                    dbg.location(319,31);
                    pushFollow(FOLLOW_statement_in_iteration_statement1726);
                    statement243=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement243.getTree());

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:320:4: 'do' statement 'while' '(' expression ')' ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(320,4);
                    string_literal244=(Token)match(input,93,FOLLOW_93_in_iteration_statement1731); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal244_tree = (CommonTree)adaptor.create(string_literal244);
                    adaptor.addChild(root_0, string_literal244_tree);
                    }
                    dbg.location(320,9);
                    pushFollow(FOLLOW_statement_in_iteration_statement1733);
                    statement245=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement245.getTree());
                    dbg.location(320,19);
                    string_literal246=(Token)match(input,92,FOLLOW_92_in_iteration_statement1735); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal246_tree = (CommonTree)adaptor.create(string_literal246);
                    adaptor.addChild(root_0, string_literal246_tree);
                    }
                    dbg.location(320,27);
                    char_literal247=(Token)match(input,53,FOLLOW_53_in_iteration_statement1737); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal247_tree = (CommonTree)adaptor.create(char_literal247);
                    adaptor.addChild(root_0, char_literal247_tree);
                    }
                    dbg.location(320,31);
                    pushFollow(FOLLOW_expression_in_iteration_statement1739);
                    expression248=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression248.getTree());
                    dbg.location(320,42);
                    char_literal249=(Token)match(input,54,FOLLOW_54_in_iteration_statement1741); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal249_tree = (CommonTree)adaptor.create(char_literal249);
                    adaptor.addChild(root_0, char_literal249_tree);
                    }
                    dbg.location(320,46);
                    char_literal250=(Token)match(input,50,FOLLOW_50_in_iteration_statement1743); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal250_tree = (CommonTree)adaptor.create(char_literal250);
                    adaptor.addChild(root_0, char_literal250_tree);
                    }

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:321:4: 'for' '(' expression ';' expression ';' ( expression )? ')' statement
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(321,4);
                    string_literal251=(Token)match(input,94,FOLLOW_94_in_iteration_statement1748); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal251_tree = (CommonTree)adaptor.create(string_literal251);
                    adaptor.addChild(root_0, string_literal251_tree);
                    }
                    dbg.location(321,10);
                    char_literal252=(Token)match(input,53,FOLLOW_53_in_iteration_statement1750); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal252_tree = (CommonTree)adaptor.create(char_literal252);
                    adaptor.addChild(root_0, char_literal252_tree);
                    }
                    dbg.location(321,14);
                    pushFollow(FOLLOW_expression_in_iteration_statement1752);
                    expression253=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression253.getTree());
                    dbg.location(321,25);
                    char_literal254=(Token)match(input,50,FOLLOW_50_in_iteration_statement1754); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal254_tree = (CommonTree)adaptor.create(char_literal254);
                    adaptor.addChild(root_0, char_literal254_tree);
                    }
                    dbg.location(321,29);
                    pushFollow(FOLLOW_expression_in_iteration_statement1756);
                    expression255=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression255.getTree());
                    dbg.location(321,40);
                    char_literal256=(Token)match(input,50,FOLLOW_50_in_iteration_statement1758); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal256_tree = (CommonTree)adaptor.create(char_literal256);
                    adaptor.addChild(root_0, char_literal256_tree);
                    }
                    dbg.location(321,44);
                    // F:\\workspace\\ESA\\grammar\\C.g:321:44: ( expression )?
                    int alt75=2;
                    try { dbg.enterSubRule(75);
                    try { dbg.enterDecision(75);

                    int LA75_0 = input.LA(1);

                    if ( ((LA75_0>=IDENTIFIER && LA75_0<=DEC)||(LA75_0>=NEG && LA75_0<=BIT_AND)||LA75_0==BIT_NEG||LA75_0==MUL||(LA75_0>=PLUS && LA75_0<=STRING_LITERAL)||LA75_0==53||LA75_0==84) ) {
                        alt75=1;
                    }
                    } finally {dbg.exitDecision(75);}

                    switch (alt75) {
                        case 1 :
                            dbg.enterAlt(1);

                            // F:\\workspace\\ESA\\grammar\\C.g:321:44: expression
                            {
                            dbg.location(321,44);
                            pushFollow(FOLLOW_expression_in_iteration_statement1760);
                            expression257=expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression257.getTree());

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(75);}

                    dbg.location(321,56);
                    char_literal258=(Token)match(input,54,FOLLOW_54_in_iteration_statement1763); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal258_tree = (CommonTree)adaptor.create(char_literal258);
                    adaptor.addChild(root_0, char_literal258_tree);
                    }
                    dbg.location(321,60);
                    pushFollow(FOLLOW_statement_in_iteration_statement1765);
                    statement259=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement259.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("iteration_statement", 59);
        }
        dbg.location(322, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "iteration_statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "iteration_statement"

    public static class jump_statement_return extends ParserRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "jump_statement"
    // F:\\workspace\\ESA\\grammar\\C.g:324:1: jump_statement : ( 'goto' IDENTIFIER ';' | 'continue' ';' | 'break' ';' | 'return' ';' | 'return' expression ';' );
    public final CParser.jump_statement_return jump_statement() throws RecognitionException {
    traceIn("jump_statement", 60);
        CParser.jump_statement_return retval = new CParser.jump_statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token string_literal260=null;
        Token IDENTIFIER261=null;
        Token char_literal262=null;
        Token string_literal263=null;
        Token char_literal264=null;
        Token string_literal265=null;
        Token char_literal266=null;
        Token string_literal267=null;
        Token char_literal268=null;
        Token string_literal269=null;
        Token char_literal271=null;
        CParser.expression_return expression270 = null;


        CommonTree string_literal260_tree=null;
        CommonTree IDENTIFIER261_tree=null;
        CommonTree char_literal262_tree=null;
        CommonTree string_literal263_tree=null;
        CommonTree char_literal264_tree=null;
        CommonTree string_literal265_tree=null;
        CommonTree char_literal266_tree=null;
        CommonTree string_literal267_tree=null;
        CommonTree char_literal268_tree=null;
        CommonTree string_literal269_tree=null;
        CommonTree char_literal271_tree=null;

        try { dbg.enterRule(getGrammarFileName(), "jump_statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(324, 1);

        try {
            // F:\\workspace\\ESA\\grammar\\C.g:325:2: ( 'goto' IDENTIFIER ';' | 'continue' ';' | 'break' ';' | 'return' ';' | 'return' expression ';' )
            int alt77=5;
            try { dbg.enterDecision(77);

            switch ( input.LA(1) ) {
            case 95:
                {
                alt77=1;
                }
                break;
            case 96:
                {
                alt77=2;
                }
                break;
            case 97:
                {
                alt77=3;
                }
                break;
            case 98:
                {
                int LA77_4 = input.LA(2);

                if ( (LA77_4==50) ) {
                    alt77=4;
                }
                else if ( ((LA77_4>=IDENTIFIER && LA77_4<=DEC)||(LA77_4>=NEG && LA77_4<=BIT_AND)||LA77_4==BIT_NEG||LA77_4==MUL||(LA77_4>=PLUS && LA77_4<=STRING_LITERAL)||LA77_4==53||LA77_4==84) ) {
                    alt77=5;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 77, 4, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 77, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(77);}

            switch (alt77) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:325:4: 'goto' IDENTIFIER ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(325,4);
                    string_literal260=(Token)match(input,95,FOLLOW_95_in_jump_statement1776); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal260_tree = (CommonTree)adaptor.create(string_literal260);
                    adaptor.addChild(root_0, string_literal260_tree);
                    }
                    dbg.location(325,11);
                    IDENTIFIER261=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_jump_statement1778); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER261_tree = (CommonTree)adaptor.create(IDENTIFIER261);
                    adaptor.addChild(root_0, IDENTIFIER261_tree);
                    }
                    dbg.location(325,22);
                    char_literal262=(Token)match(input,50,FOLLOW_50_in_jump_statement1780); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal262_tree = (CommonTree)adaptor.create(char_literal262);
                    adaptor.addChild(root_0, char_literal262_tree);
                    }

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // F:\\workspace\\ESA\\grammar\\C.g:326:4: 'continue' ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(326,4);
                    string_literal263=(Token)match(input,96,FOLLOW_96_in_jump_statement1785); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal263_tree = (CommonTree)adaptor.create(string_literal263);
                    adaptor.addChild(root_0, string_literal263_tree);
                    }
                    dbg.location(326,15);
                    char_literal264=(Token)match(input,50,FOLLOW_50_in_jump_statement1787); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal264_tree = (CommonTree)adaptor.create(char_literal264);
                    adaptor.addChild(root_0, char_literal264_tree);
                    }

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // F:\\workspace\\ESA\\grammar\\C.g:327:4: 'break' ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(327,4);
                    string_literal265=(Token)match(input,97,FOLLOW_97_in_jump_statement1792); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal265_tree = (CommonTree)adaptor.create(string_literal265);
                    adaptor.addChild(root_0, string_literal265_tree);
                    }
                    dbg.location(327,12);
                    char_literal266=(Token)match(input,50,FOLLOW_50_in_jump_statement1794); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal266_tree = (CommonTree)adaptor.create(char_literal266);
                    adaptor.addChild(root_0, char_literal266_tree);
                    }

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // F:\\workspace\\ESA\\grammar\\C.g:328:4: 'return' ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(328,4);
                    string_literal267=(Token)match(input,98,FOLLOW_98_in_jump_statement1799); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal267_tree = (CommonTree)adaptor.create(string_literal267);
                    adaptor.addChild(root_0, string_literal267_tree);
                    }
                    dbg.location(328,13);
                    char_literal268=(Token)match(input,50,FOLLOW_50_in_jump_statement1801); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal268_tree = (CommonTree)adaptor.create(char_literal268);
                    adaptor.addChild(root_0, char_literal268_tree);
                    }

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // F:\\workspace\\ESA\\grammar\\C.g:329:4: 'return' expression ';'
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    dbg.location(329,4);
                    string_literal269=(Token)match(input,98,FOLLOW_98_in_jump_statement1806); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal269_tree = (CommonTree)adaptor.create(string_literal269);
                    adaptor.addChild(root_0, string_literal269_tree);
                    }
                    dbg.location(329,13);
                    pushFollow(FOLLOW_expression_in_jump_statement1808);
                    expression270=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression270.getTree());
                    dbg.location(329,24);
                    char_literal271=(Token)match(input,50,FOLLOW_50_in_jump_statement1810); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal271_tree = (CommonTree)adaptor.create(char_literal271);
                    adaptor.addChild(root_0, char_literal271_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
    traceOut("jump_statement", 60);
        }
        dbg.location(330, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "jump_statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "jump_statement"

    // $ANTLR start synpred1_C
    public final void synpred1_C_fragment() throws RecognitionException {   
        traceIn("synpred1_C_fragment", 61);
        try {
            // F:\\workspace\\ESA\\grammar\\C.g:50:5: ( ( specifiers )? ( pointer )? direct_declarator '{' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:50:7: ( specifiers )? ( pointer )? direct_declarator '{'
            {
            dbg.location(50,7);
            // F:\\workspace\\ESA\\grammar\\C.g:50:7: ( specifiers )?
            int alt78=2;
            try { dbg.enterSubRule(78);
            try { dbg.enterDecision(78);

            try {
                isCyclicDecision = true;
                alt78 = dfa78.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(78);}

            switch (alt78) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:50:7: specifiers
                    {
                    dbg.location(50,7);
                    pushFollow(FOLLOW_specifiers_in_synpred1_C135);
                    specifiers();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(78);}

            dbg.location(50,19);
            // F:\\workspace\\ESA\\grammar\\C.g:50:19: ( pointer )?
            int alt79=2;
            try { dbg.enterSubRule(79);
            try { dbg.enterDecision(79);

            int LA79_0 = input.LA(1);

            if ( (LA79_0==MUL) ) {
                alt79=1;
            }
            } finally {dbg.exitDecision(79);}

            switch (alt79) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:50:19: pointer
                    {
                    dbg.location(50,19);
                    pushFollow(FOLLOW_pointer_in_synpred1_C138);
                    pointer();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(79);}

            dbg.location(50,28);
            pushFollow(FOLLOW_direct_declarator_in_synpred1_C141);
            direct_declarator();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(50,46);
            match(input,47,FOLLOW_47_in_synpred1_C143); if (state.failed) return ;

            }

        }
        finally {
            traceOut("synpred1_C_fragment", 61);
        }}
    // $ANTLR end synpred1_C

    // $ANTLR start synpred2_C
    public final void synpred2_C_fragment() throws RecognitionException {   
        traceIn("synpred2_C_fragment", 62);
        try {
            // F:\\workspace\\ESA\\grammar\\C.g:154:4: ( ( declarator )? ':' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:154:5: ( declarator )? ':'
            {
            dbg.location(154,5);
            // F:\\workspace\\ESA\\grammar\\C.g:154:5: ( declarator )?
            int alt80=2;
            try { dbg.enterSubRule(80);
            try { dbg.enterDecision(80);

            int LA80_0 = input.LA(1);

            if ( (LA80_0==IDENTIFIER||LA80_0==MUL||LA80_0==53) ) {
                alt80=1;
            }
            } finally {dbg.exitDecision(80);}

            switch (alt80) {
                case 1 :
                    dbg.enterAlt(1);

                    // F:\\workspace\\ESA\\grammar\\C.g:154:5: declarator
                    {
                    dbg.location(154,5);
                    pushFollow(FOLLOW_declarator_in_synpred2_C726);
                    declarator();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(80);}

            dbg.location(154,17);
            match(input,75,FOLLOW_75_in_synpred2_C729); if (state.failed) return ;

            }

        }
        finally {
            traceOut("synpred2_C_fragment", 62);
        }}
    // $ANTLR end synpred2_C

    // $ANTLR start synpred3_C
    public final void synpred3_C_fragment() throws RecognitionException {   
        traceIn("synpred3_C_fragment", 63);
        try {
            // F:\\workspace\\ESA\\grammar\\C.g:191:4: ( lvalue assign_op )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:191:5: lvalue assign_op
            {
            dbg.location(191,5);
            pushFollow(FOLLOW_lvalue_in_synpred3_C907);
            lvalue();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(191,12);
            pushFollow(FOLLOW_assign_op_in_synpred3_C909);
            assign_op();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        finally {
            traceOut("synpred3_C_fragment", 63);
        }}
    // $ANTLR end synpred3_C

    // $ANTLR start synpred4_C
    public final void synpred4_C_fragment() throws RecognitionException {   
        traceIn("synpred4_C_fragment", 64);
        try {
            // F:\\workspace\\ESA\\grammar\\C.g:200:4: ( logical_or_expression '?' )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:200:5: logical_or_expression '?'
            {
            dbg.location(200,5);
            pushFollow(FOLLOW_logical_or_expression_in_synpred4_C990);
            logical_or_expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(200,27);
            match(input,77,FOLLOW_77_in_synpred4_C992); if (state.failed) return ;

            }

        }
        finally {
            traceOut("synpred4_C_fragment", 64);
        }}
    // $ANTLR end synpred4_C

    // $ANTLR start synpred5_C
    public final void synpred5_C_fragment() throws RecognitionException {   
        traceIn("synpred5_C_fragment", 65);
        try {
            // F:\\workspace\\ESA\\grammar\\C.g:234:4: ( '(' specifiers )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:234:5: '(' specifiers
            {
            dbg.location(234,5);
            match(input,53,FOLLOW_53_in_synpred5_C1225); if (state.failed) return ;
            dbg.location(234,9);
            pushFollow(FOLLOW_specifiers_in_synpred5_C1227);
            specifiers();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        finally {
            traceOut("synpred5_C_fragment", 65);
        }}
    // $ANTLR end synpred5_C

    // $ANTLR start synpred6_C
    public final void synpred6_C_fragment() throws RecognitionException {   
        traceIn("synpred6_C_fragment", 66);
        try {
            // F:\\workspace\\ESA\\grammar\\C.g:242:4: ( 'sizeof' '(' specifiers )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:242:5: 'sizeof' '(' specifiers
            {
            dbg.location(242,5);
            match(input,84,FOLLOW_84_in_synpred6_C1283); if (state.failed) return ;
            dbg.location(242,14);
            match(input,53,FOLLOW_53_in_synpred6_C1285); if (state.failed) return ;
            dbg.location(242,18);
            pushFollow(FOLLOW_specifiers_in_synpred6_C1287);
            specifiers();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        finally {
            traceOut("synpred6_C_fragment", 66);
        }}
    // $ANTLR end synpred6_C

    // $ANTLR start synpred7_C
    public final void synpred7_C_fragment() throws RecognitionException {   
        traceIn("synpred7_C_fragment", 67);
        try {
            // F:\\workspace\\ESA\\grammar\\C.g:313:4: ( 'if' '(' expression ')' statement ( 'else' statement ) )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:313:4: 'if' '(' expression ')' statement ( 'else' statement )
            {
            dbg.location(313,4);
            match(input,89,FOLLOW_89_in_synpred7_C1667); if (state.failed) return ;
            dbg.location(313,9);
            match(input,53,FOLLOW_53_in_synpred7_C1669); if (state.failed) return ;
            dbg.location(313,13);
            pushFollow(FOLLOW_expression_in_synpred7_C1671);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(313,24);
            match(input,54,FOLLOW_54_in_synpred7_C1673); if (state.failed) return ;
            dbg.location(313,28);
            pushFollow(FOLLOW_statement_in_synpred7_C1675);
            statement();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(313,38);
            // F:\\workspace\\ESA\\grammar\\C.g:313:38: ( 'else' statement )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:313:39: 'else' statement
            {
            dbg.location(313,39);
            match(input,90,FOLLOW_90_in_synpred7_C1678); if (state.failed) return ;
            dbg.location(313,46);
            pushFollow(FOLLOW_statement_in_synpred7_C1680);
            statement();

            state._fsp--;
            if (state.failed) return ;

            }


            }

        }
        finally {
            traceOut("synpred7_C_fragment", 67);
        }}
    // $ANTLR end synpred7_C

    // $ANTLR start synpred8_C
    public final void synpred8_C_fragment() throws RecognitionException {   
        traceIn("synpred8_C_fragment", 68);
        try {
            // F:\\workspace\\ESA\\grammar\\C.g:314:4: ( 'if' '(' expression ')' statement )
            dbg.enterAlt(1);

            // F:\\workspace\\ESA\\grammar\\C.g:314:4: 'if' '(' expression ')' statement
            {
            dbg.location(314,4);
            match(input,89,FOLLOW_89_in_synpred8_C1686); if (state.failed) return ;
            dbg.location(314,9);
            match(input,53,FOLLOW_53_in_synpred8_C1688); if (state.failed) return ;
            dbg.location(314,13);
            pushFollow(FOLLOW_expression_in_synpred8_C1690);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(314,24);
            match(input,54,FOLLOW_54_in_synpred8_C1692); if (state.failed) return ;
            dbg.location(314,28);
            pushFollow(FOLLOW_statement_in_synpred8_C1694);
            statement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        finally {
            traceOut("synpred8_C_fragment", 68);
        }}
    // $ANTLR end synpred8_C

    // Delegated rules

    public final boolean synpred5_C() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred5_C_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred1_C() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred1_C_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred6_C() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred6_C_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred2_C() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred2_C_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred7_C() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred7_C_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred3_C() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred3_C_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred8_C() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred8_C_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred4_C() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred4_C_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA2 dfa2 = new DFA2(this);
    protected DFA3 dfa3 = new DFA3(this);
    protected DFA4 dfa4 = new DFA4(this);
    protected DFA35 dfa35 = new DFA35(this);
    protected DFA41 dfa41 = new DFA41(this);
    protected DFA48 dfa48 = new DFA48(this);
    protected DFA51 dfa51 = new DFA51(this);
    protected DFA62 dfa62 = new DFA62(this);
    protected DFA63 dfa63 = new DFA63(this);
    protected DFA70 dfa70 = new DFA70(this);
    protected DFA78 dfa78 = new DFA78(this);
    static final String DFA2_eotS =
        "\15\uffff";
    static final String DFA2_eofS =
        "\15\uffff";
    static final String DFA2_minS =
        "\1\14\11\0\3\uffff";
    static final String DFA2_maxS =
        "\1\114\11\0\3\uffff";
    static final String DFA2_acceptS =
        "\12\uffff\2\1\1\2";
    static final String DFA2_specialS =
        "\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\3\uffff}>";
    static final String[] DFA2_transitionS = {
            "\1\10\13\uffff\1\12\30\uffff\1\14\3\uffff\1\13\4\uffff\4\1"+
            "\1\2\2\3\2\4\4\5\2\11\2\6\1\uffff\1\7",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
    static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
    static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
    static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
    static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
    static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
    static final short[][] DFA2_transition;

    static {
        int numStates = DFA2_transitionS.length;
        DFA2_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
        }
    }

    class DFA2 extends DFA {

        public DFA2(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 2;
            this.eot = DFA2_eot;
            this.eof = DFA2_eof;
            this.min = DFA2_min;
            this.max = DFA2_max;
            this.accept = DFA2_accept;
            this.special = DFA2_special;
            this.transition = DFA2_transition;
        }
        public String getDescription() {
            return "49:1: definition : ( ( ( specifiers )? ( pointer )? direct_declarator '{' )=> function | declaration );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA2_0 = input.LA(1);

                         
                        int index2_0 = input.index();
                        input.rewind();
                        s = -1;
                        if ( ((LA2_0>=58 && LA2_0<=61)) ) {s = 1;}

                        else if ( (LA2_0==62) ) {s = 2;}

                        else if ( ((LA2_0>=63 && LA2_0<=64)) ) {s = 3;}

                        else if ( ((LA2_0>=65 && LA2_0<=66)) ) {s = 4;}

                        else if ( ((LA2_0>=67 && LA2_0<=70)) ) {s = 5;}

                        else if ( ((LA2_0>=73 && LA2_0<=74)) ) {s = 6;}

                        else if ( (LA2_0==76) ) {s = 7;}

                        else if ( (LA2_0==IDENTIFIER) ) {s = 8;}

                        else if ( ((LA2_0>=71 && LA2_0<=72)) ) {s = 9;}

                        else if ( (LA2_0==MUL) && (synpred1_C())) {s = 10;}

                        else if ( (LA2_0==53) && (synpred1_C())) {s = 11;}

                        else if ( (LA2_0==49) ) {s = 12;}

                         
                        input.seek(index2_0);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA2_1 = input.LA(1);

                         
                        int index2_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred1_C()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index2_1);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA2_2 = input.LA(1);

                         
                        int index2_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred1_C()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index2_2);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA2_3 = input.LA(1);

                         
                        int index2_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred1_C()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index2_3);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA2_4 = input.LA(1);

                         
                        int index2_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred1_C()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index2_4);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA2_5 = input.LA(1);

                         
                        int index2_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred1_C()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index2_5);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA2_6 = input.LA(1);

                         
                        int index2_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred1_C()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index2_6);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA2_7 = input.LA(1);

                         
                        int index2_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred1_C()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index2_7);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA2_8 = input.LA(1);

                         
                        int index2_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( ((synpred1_C()||(synpred1_C()&&evalPredicate(isTypeName(input.LT(1).getText()),"isTypeName(input.LT(1).getText())")))) ) {s = 11;}

                        else if ( (evalPredicate(isTypeName(input.LT(1).getText()),"isTypeName(input.LT(1).getText())")) ) {s = 12;}

                         
                        input.seek(index2_8);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA2_9 = input.LA(1);

                         
                        int index2_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred1_C()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index2_9);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 2, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA3_eotS =
        "\14\uffff";
    static final String DFA3_eofS =
        "\14\uffff";
    static final String DFA3_minS =
        "\1\14\7\uffff\1\0\3\uffff";
    static final String DFA3_maxS =
        "\1\114\7\uffff\1\0\3\uffff";
    static final String DFA3_acceptS =
        "\1\uffff\1\1\10\uffff\1\2\1\uffff";
    static final String DFA3_specialS =
        "\10\uffff\1\0\3\uffff}>";
    static final String[] DFA3_transitionS = {
            "\1\10\13\uffff\1\12\34\uffff\1\12\4\uffff\21\1\1\uffff\1\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] DFA3_eot = DFA.unpackEncodedString(DFA3_eotS);
    static final short[] DFA3_eof = DFA.unpackEncodedString(DFA3_eofS);
    static final char[] DFA3_min = DFA.unpackEncodedStringToUnsignedChars(DFA3_minS);
    static final char[] DFA3_max = DFA.unpackEncodedStringToUnsignedChars(DFA3_maxS);
    static final short[] DFA3_accept = DFA.unpackEncodedString(DFA3_acceptS);
    static final short[] DFA3_special = DFA.unpackEncodedString(DFA3_specialS);
    static final short[][] DFA3_transition;

    static {
        int numStates = DFA3_transitionS.length;
        DFA3_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA3_transition[i] = DFA.unpackEncodedString(DFA3_transitionS[i]);
        }
    }

    class DFA3 extends DFA {

        public DFA3(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 3;
            this.eot = DFA3_eot;
            this.eof = DFA3_eof;
            this.min = DFA3_min;
            this.max = DFA3_max;
            this.accept = DFA3_accept;
            this.special = DFA3_special;
            this.transition = DFA3_transition;
        }
        public String getDescription() {
            return "58:4: ( specifiers )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA3_8 = input.LA(1);

                         
                        int index3_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (evalPredicate(isTypeName(input.LT(1).getText()),"isTypeName(input.LT(1).getText())")) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index3_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 3, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA4_eotS =
        "\40\uffff";
    static final String DFA4_eofS =
        "\40\uffff";
    static final String DFA4_minS =
        "\1\14\1\0\36\uffff";
    static final String DFA4_maxS =
        "\1\142\1\0\36\uffff";
    static final String DFA4_acceptS =
        "\2\uffff\1\2\24\uffff\1\1\10\uffff";
    static final String DFA4_specialS =
        "\1\uffff\1\0\36\uffff}>";
    static final String[] DFA4_transitionS = {
            "\1\1\2\2\2\uffff\2\2\1\uffff\1\2\3\uffff\1\2\2\uffff\10\2\14"+
            "\uffff\2\2\1\27\1\2\2\uffff\1\2\4\uffff\21\27\1\uffff\1\27\7"+
            "\uffff\1\2\2\uffff\3\2\1\uffff\10\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
    static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
    static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
    static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
    static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
    static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
    static final short[][] DFA4_transition;

    static {
        int numStates = DFA4_transitionS.length;
        DFA4_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
        }
    }

    class DFA4 extends DFA {

        public DFA4(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 4;
            this.eot = DFA4_eot;
            this.eof = DFA4_eof;
            this.min = DFA4_min;
            this.max = DFA4_max;
            this.accept = DFA4_accept;
            this.special = DFA4_special;
            this.transition = DFA4_transition;
        }
        public String getDescription() {
            return "()* loopback of 58:31: ( declaration )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA4_1 = input.LA(1);

                         
                        int index4_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (evalPredicate(isTypeName(input.LT(1).getText()),"isTypeName(input.LT(1).getText())")) ) {s = 23;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index4_1);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 4, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA35_eotS =
        "\25\uffff";
    static final String DFA35_eofS =
        "\2\uffff\1\5\22\uffff";
    static final String DFA35_minS =
        "\1\111\2\14\22\uffff";
    static final String DFA35_maxS =
        "\1\112\1\57\1\114\22\uffff";
    static final String DFA35_acceptS =
        "\3\uffff\1\1\1\uffff\1\2\17\uffff";
    static final String DFA35_specialS =
        "\25\uffff}>";
    static final String[] DFA35_transitionS = {
            "\2\1",
            "\1\2\42\uffff\1\3",
            "\1\5\13\uffff\1\5\26\uffff\1\3\2\uffff\2\5\1\uffff\2\5\3\uffff"+
            "\23\5",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA35_eot = DFA.unpackEncodedString(DFA35_eotS);
    static final short[] DFA35_eof = DFA.unpackEncodedString(DFA35_eofS);
    static final char[] DFA35_min = DFA.unpackEncodedStringToUnsignedChars(DFA35_minS);
    static final char[] DFA35_max = DFA.unpackEncodedStringToUnsignedChars(DFA35_maxS);
    static final short[] DFA35_accept = DFA.unpackEncodedString(DFA35_acceptS);
    static final short[] DFA35_special = DFA.unpackEncodedString(DFA35_specialS);
    static final short[][] DFA35_transition;

    static {
        int numStates = DFA35_transitionS.length;
        DFA35_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA35_transition[i] = DFA.unpackEncodedString(DFA35_transitionS[i]);
        }
    }

    class DFA35 extends DFA {

        public DFA35(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 35;
            this.eot = DFA35_eot;
            this.eof = DFA35_eof;
            this.min = DFA35_min;
            this.max = DFA35_max;
            this.accept = DFA35_accept;
            this.special = DFA35_special;
            this.transition = DFA35_transition;
        }
        public String getDescription() {
            return "134:1: struct_or_union_specifier options {k=3; } : ( ( 'struct' | 'union' ) ( IDENTIFIER )? '{' struct_declaration_list '}' | ( 'struct' | 'union' ) IDENTIFIER );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA41_eotS =
        "\25\uffff";
    static final String DFA41_eofS =
        "\2\uffff\1\4\22\uffff";
    static final String DFA41_minS =
        "\1\114\2\14\22\uffff";
    static final String DFA41_maxS =
        "\1\114\1\57\1\114\22\uffff";
    static final String DFA41_acceptS =
        "\3\uffff\1\1\1\2\20\uffff";
    static final String DFA41_specialS =
        "\25\uffff}>";
    static final String[] DFA41_transitionS = {
            "\1\1",
            "\1\2\42\uffff\1\3",
            "\1\4\13\uffff\1\4\26\uffff\1\3\2\uffff\2\4\1\uffff\2\4\3\uffff"+
            "\23\4",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA41_eot = DFA.unpackEncodedString(DFA41_eotS);
    static final short[] DFA41_eof = DFA.unpackEncodedString(DFA41_eofS);
    static final char[] DFA41_min = DFA.unpackEncodedStringToUnsignedChars(DFA41_minS);
    static final char[] DFA41_max = DFA.unpackEncodedStringToUnsignedChars(DFA41_maxS);
    static final short[] DFA41_accept = DFA.unpackEncodedString(DFA41_acceptS);
    static final short[] DFA41_special = DFA.unpackEncodedString(DFA41_specialS);
    static final short[][] DFA41_transition;

    static {
        int numStates = DFA41_transitionS.length;
        DFA41_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA41_transition[i] = DFA.unpackEncodedString(DFA41_transitionS[i]);
        }
    }

    class DFA41 extends DFA {

        public DFA41(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 41;
            this.eot = DFA41_eot;
            this.eof = DFA41_eof;
            this.min = DFA41_min;
            this.max = DFA41_max;
            this.accept = DFA41_accept;
            this.special = DFA41_special;
            this.transition = DFA41_transition;
        }
        public String getDescription() {
            return "158:1: enum_specifier options {k=3; } : ( 'enum' ( IDENTIFIER )? '{' enumerator_list '}' | 'enum' IDENTIFIER );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA48_eotS =
        "\12\uffff";
    static final String DFA48_eofS =
        "\12\uffff";
    static final String DFA48_minS =
        "\1\14\6\0\3\uffff";
    static final String DFA48_maxS =
        "\1\124\6\0\3\uffff";
    static final String DFA48_acceptS =
        "\7\uffff\1\2\1\uffff\1\1";
    static final String DFA48_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\3\uffff}>";
    static final String[] DFA48_transitionS = {
            "\1\4\2\1\2\uffff\1\7\1\2\1\uffff\1\7\3\uffff\1\3\2\uffff\2"+
            "\7\6\5\22\uffff\1\6\36\uffff\1\7",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] DFA48_eot = DFA.unpackEncodedString(DFA48_eotS);
    static final short[] DFA48_eof = DFA.unpackEncodedString(DFA48_eofS);
    static final char[] DFA48_min = DFA.unpackEncodedStringToUnsignedChars(DFA48_minS);
    static final char[] DFA48_max = DFA.unpackEncodedStringToUnsignedChars(DFA48_maxS);
    static final short[] DFA48_accept = DFA.unpackEncodedString(DFA48_acceptS);
    static final short[] DFA48_special = DFA.unpackEncodedString(DFA48_specialS);
    static final short[][] DFA48_transition;

    static {
        int numStates = DFA48_transitionS.length;
        DFA48_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA48_transition[i] = DFA.unpackEncodedString(DFA48_transitionS[i]);
        }
    }

    class DFA48 extends DFA {

        public DFA48(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 48;
            this.eot = DFA48_eot;
            this.eof = DFA48_eof;
            this.min = DFA48_min;
            this.max = DFA48_max;
            this.accept = DFA48_accept;
            this.special = DFA48_special;
            this.transition = DFA48_transition;
        }
        public String getDescription() {
            return "190:1: assignment_expression : ( ( lvalue assign_op )=> lvalue assign_op assignment_expression | conditional_expression );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA48_1 = input.LA(1);

                         
                        int index48_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred3_C()) ) {s = 9;}

                        else if ( (true) ) {s = 7;}

                         
                        input.seek(index48_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA48_2 = input.LA(1);

                         
                        int index48_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred3_C()) ) {s = 9;}

                        else if ( (true) ) {s = 7;}

                         
                        input.seek(index48_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA48_3 = input.LA(1);

                         
                        int index48_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred3_C()) ) {s = 9;}

                        else if ( (true) ) {s = 7;}

                         
                        input.seek(index48_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA48_4 = input.LA(1);

                         
                        int index48_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred3_C()) ) {s = 9;}

                        else if ( (true) ) {s = 7;}

                         
                        input.seek(index48_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA48_5 = input.LA(1);

                         
                        int index48_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred3_C()) ) {s = 9;}

                        else if ( (true) ) {s = 7;}

                         
                        input.seek(index48_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA48_6 = input.LA(1);

                         
                        int index48_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred3_C()) ) {s = 9;}

                        else if ( (true) ) {s = 7;}

                         
                        input.seek(index48_6);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 48, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA51_eotS =
        "\13\uffff";
    static final String DFA51_eofS =
        "\13\uffff";
    static final String DFA51_minS =
        "\1\14\10\0\2\uffff";
    static final String DFA51_maxS =
        "\1\124\10\0\2\uffff";
    static final String DFA51_acceptS =
        "\11\uffff\1\1\1\2";
    static final String DFA51_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\2\uffff}>";
    static final String[] DFA51_transitionS = {
            "\1\4\2\6\2\uffff\1\7\1\2\1\uffff\1\7\3\uffff\1\3\2\uffff\2"+
            "\7\6\5\22\uffff\1\1\36\uffff\1\10",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA51_eot = DFA.unpackEncodedString(DFA51_eotS);
    static final short[] DFA51_eof = DFA.unpackEncodedString(DFA51_eofS);
    static final char[] DFA51_min = DFA.unpackEncodedStringToUnsignedChars(DFA51_minS);
    static final char[] DFA51_max = DFA.unpackEncodedStringToUnsignedChars(DFA51_maxS);
    static final short[] DFA51_accept = DFA.unpackEncodedString(DFA51_acceptS);
    static final short[] DFA51_special = DFA.unpackEncodedString(DFA51_specialS);
    static final short[][] DFA51_transition;

    static {
        int numStates = DFA51_transitionS.length;
        DFA51_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA51_transition[i] = DFA.unpackEncodedString(DFA51_transitionS[i]);
        }
    }

    class DFA51 extends DFA {

        public DFA51(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 51;
            this.eot = DFA51_eot;
            this.eof = DFA51_eof;
            this.min = DFA51_min;
            this.max = DFA51_max;
            this.accept = DFA51_accept;
            this.special = DFA51_special;
            this.transition = DFA51_transition;
        }
        public String getDescription() {
            return "199:1: conditional_expression : ( ( logical_or_expression '?' )=> logical_or_expression '?' logical_or_expression ':' conditional_expression | logical_or_expression );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA51_1 = input.LA(1);

                         
                        int index51_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred4_C()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index51_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA51_2 = input.LA(1);

                         
                        int index51_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred4_C()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index51_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA51_3 = input.LA(1);

                         
                        int index51_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred4_C()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index51_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA51_4 = input.LA(1);

                         
                        int index51_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred4_C()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index51_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA51_5 = input.LA(1);

                         
                        int index51_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred4_C()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index51_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA51_6 = input.LA(1);

                         
                        int index51_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred4_C()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index51_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA51_7 = input.LA(1);

                         
                        int index51_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred4_C()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index51_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA51_8 = input.LA(1);

                         
                        int index51_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred4_C()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index51_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 51, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA62_eotS =
        "\12\uffff";
    static final String DFA62_eofS =
        "\12\uffff";
    static final String DFA62_minS =
        "\1\14\1\0\10\uffff";
    static final String DFA62_maxS =
        "\1\124\1\0\10\uffff";
    static final String DFA62_acceptS =
        "\2\uffff\1\2\6\uffff\1\1";
    static final String DFA62_specialS =
        "\1\uffff\1\0\10\uffff}>";
    static final String[] DFA62_transitionS = {
            "\3\2\2\uffff\2\2\1\uffff\1\2\3\uffff\1\2\2\uffff\10\2\22\uffff"+
            "\1\1\36\uffff\1\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA62_eot = DFA.unpackEncodedString(DFA62_eotS);
    static final short[] DFA62_eof = DFA.unpackEncodedString(DFA62_eofS);
    static final char[] DFA62_min = DFA.unpackEncodedStringToUnsignedChars(DFA62_minS);
    static final char[] DFA62_max = DFA.unpackEncodedStringToUnsignedChars(DFA62_maxS);
    static final short[] DFA62_accept = DFA.unpackEncodedString(DFA62_acceptS);
    static final short[] DFA62_special = DFA.unpackEncodedString(DFA62_specialS);
    static final short[][] DFA62_transition;

    static {
        int numStates = DFA62_transitionS.length;
        DFA62_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA62_transition[i] = DFA.unpackEncodedString(DFA62_transitionS[i]);
        }
    }

    class DFA62 extends DFA {

        public DFA62(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 62;
            this.eot = DFA62_eot;
            this.eof = DFA62_eof;
            this.min = DFA62_min;
            this.max = DFA62_max;
            this.accept = DFA62_accept;
            this.special = DFA62_special;
            this.transition = DFA62_transition;
        }
        public String getDescription() {
            return "233:1: cast_expression : ( ( '(' specifiers )=> '(' type_name ')' cast_expression | unary_expression );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA62_1 = input.LA(1);

                         
                        int index62_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred5_C()) ) {s = 9;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index62_1);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 62, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA63_eotS =
        "\13\uffff";
    static final String DFA63_eofS =
        "\13\uffff";
    static final String DFA63_minS =
        "\1\14\7\uffff\1\0\2\uffff";
    static final String DFA63_maxS =
        "\1\124\7\uffff\1\0\2\uffff";
    static final String DFA63_acceptS =
        "\1\uffff\1\1\4\uffff\1\2\1\3\1\uffff\1\4\1\5";
    static final String DFA63_specialS =
        "\10\uffff\1\0\2\uffff}>";
    static final String[] DFA63_transitionS = {
            "\1\1\2\6\2\uffff\1\7\1\1\1\uffff\1\7\3\uffff\1\1\2\uffff\2"+
            "\7\6\1\22\uffff\1\1\36\uffff\1\10",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA63_eot = DFA.unpackEncodedString(DFA63_eotS);
    static final short[] DFA63_eof = DFA.unpackEncodedString(DFA63_eofS);
    static final char[] DFA63_min = DFA.unpackEncodedStringToUnsignedChars(DFA63_minS);
    static final char[] DFA63_max = DFA.unpackEncodedStringToUnsignedChars(DFA63_maxS);
    static final short[] DFA63_accept = DFA.unpackEncodedString(DFA63_acceptS);
    static final short[] DFA63_special = DFA.unpackEncodedString(DFA63_specialS);
    static final short[][] DFA63_transition;

    static {
        int numStates = DFA63_transitionS.length;
        DFA63_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA63_transition[i] = DFA.unpackEncodedString(DFA63_transitionS[i]);
        }
    }

    class DFA63 extends DFA {

        public DFA63(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 63;
            this.eot = DFA63_eot;
            this.eof = DFA63_eof;
            this.min = DFA63_min;
            this.max = DFA63_max;
            this.accept = DFA63_accept;
            this.special = DFA63_special;
            this.transition = DFA63_transition;
        }
        public String getDescription() {
            return "237:1: unary_expression : ( prefix_expression | ( INC | DEC ) cast_expression | unary_operator cast_expression | 'sizeof' prefix_expression | ( 'sizeof' '(' specifiers )=> 'sizeof' '(' type_name ')' );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA63_8 = input.LA(1);

                         
                        int index63_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (true) ) {s = 9;}

                        else if ( (synpred6_C()) ) {s = 10;}

                         
                        input.seek(index63_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 63, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA70_eotS =
        "\40\uffff";
    static final String DFA70_eofS =
        "\40\uffff";
    static final String DFA70_minS =
        "\1\14\1\0\36\uffff";
    static final String DFA70_maxS =
        "\1\142\1\0\36\uffff";
    static final String DFA70_acceptS =
        "\2\uffff\1\2\24\uffff\1\1\10\uffff";
    static final String DFA70_specialS =
        "\1\uffff\1\0\36\uffff}>";
    static final String[] DFA70_transitionS = {
            "\1\1\2\2\2\uffff\2\2\1\uffff\1\2\3\uffff\1\2\2\uffff\10\2\14"+
            "\uffff\2\2\1\27\1\2\2\uffff\1\2\4\uffff\21\27\1\uffff\1\27\7"+
            "\uffff\1\2\2\uffff\3\2\1\uffff\10\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA70_eot = DFA.unpackEncodedString(DFA70_eotS);
    static final short[] DFA70_eof = DFA.unpackEncodedString(DFA70_eofS);
    static final char[] DFA70_min = DFA.unpackEncodedStringToUnsignedChars(DFA70_minS);
    static final char[] DFA70_max = DFA.unpackEncodedStringToUnsignedChars(DFA70_maxS);
    static final short[] DFA70_accept = DFA.unpackEncodedString(DFA70_acceptS);
    static final short[] DFA70_special = DFA.unpackEncodedString(DFA70_specialS);
    static final short[][] DFA70_transition;

    static {
        int numStates = DFA70_transitionS.length;
        DFA70_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA70_transition[i] = DFA.unpackEncodedString(DFA70_transitionS[i]);
        }
    }

    class DFA70 extends DFA {

        public DFA70(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 70;
            this.eot = DFA70_eot;
            this.eof = DFA70_eof;
            this.min = DFA70_min;
            this.max = DFA70_max;
            this.accept = DFA70_accept;
            this.special = DFA70_special;
            this.transition = DFA70_transition;
        }
        public String getDescription() {
            return "()* loopback of 300:9: ( declaration )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA70_1 = input.LA(1);

                         
                        int index70_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (evalPredicate(isTypeName(input.LT(1).getText()),"isTypeName(input.LT(1).getText())")) ) {s = 23;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index70_1);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 70, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA78_eotS =
        "\14\uffff";
    static final String DFA78_eofS =
        "\14\uffff";
    static final String DFA78_minS =
        "\1\14\7\uffff\1\0\3\uffff";
    static final String DFA78_maxS =
        "\1\114\7\uffff\1\0\3\uffff";
    static final String DFA78_acceptS =
        "\1\uffff\1\1\10\uffff\1\2\1\uffff";
    static final String DFA78_specialS =
        "\10\uffff\1\0\3\uffff}>";
    static final String[] DFA78_transitionS = {
            "\1\10\13\uffff\1\12\34\uffff\1\12\4\uffff\21\1\1\uffff\1\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] DFA78_eot = DFA.unpackEncodedString(DFA78_eotS);
    static final short[] DFA78_eof = DFA.unpackEncodedString(DFA78_eofS);
    static final char[] DFA78_min = DFA.unpackEncodedStringToUnsignedChars(DFA78_minS);
    static final char[] DFA78_max = DFA.unpackEncodedStringToUnsignedChars(DFA78_maxS);
    static final short[] DFA78_accept = DFA.unpackEncodedString(DFA78_acceptS);
    static final short[] DFA78_special = DFA.unpackEncodedString(DFA78_specialS);
    static final short[][] DFA78_transition;

    static {
        int numStates = DFA78_transitionS.length;
        DFA78_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA78_transition[i] = DFA.unpackEncodedString(DFA78_transitionS[i]);
        }
    }

    class DFA78 extends DFA {

        public DFA78(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 78;
            this.eot = DFA78_eot;
            this.eof = DFA78_eof;
            this.min = DFA78_min;
            this.max = DFA78_max;
            this.accept = DFA78_accept;
            this.special = DFA78_special;
            this.transition = DFA78_transition;
        }
        public String getDescription() {
            return "50:7: ( specifiers )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA78_8 = input.LA(1);

                         
                        int index78_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (evalPredicate(isTypeName(input.LT(1).getText()),"isTypeName(input.LT(1).getText())")) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index78_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 78, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

    public static final BitSet FOLLOW_definition_in_unit120 = new BitSet(new long[]{0xFC22000001001002L,0x00000000000017FFL});
    public static final BitSet FOLLOW_function_in_definition148 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_declaration_in_definition153 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_specifiers_in_function174 = new BitSet(new long[]{0xFC20000001001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_declarator_in_function177 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_function179 = new BitSet(new long[]{0xFC278007F9167000L,0x00000007FB9017FFL});
    public static final BitSet FOLLOW_declaration_in_function181 = new BitSet(new long[]{0xFC278007F9167000L,0x00000007FB9017FFL});
    public static final BitSet FOLLOW_statement_in_function184 = new BitSet(new long[]{0x00258007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_48_in_function187 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_49_in_declaration207 = new BitSet(new long[]{0xFC00000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_specifiers_in_declaration209 = new BitSet(new long[]{0xFC20000001001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_init_declarator_list_in_declaration212 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_declaration214 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_specifiers_in_declaration220 = new BitSet(new long[]{0xFC24000001001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_init_declarator_list_in_declaration222 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_declaration225 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_init_declarator_in_init_declarator_list235 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_51_in_init_declarator_list238 = new BitSet(new long[]{0xFC20000001001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_init_declarator_in_init_declarator_list240 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_declarator_in_init_declarator252 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_init_declarator255 = new BitSet(new long[]{0x00248007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_initializer_in_init_declarator257 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_pointer_in_declarator269 = new BitSet(new long[]{0xFC20000001001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_direct_declarator_in_declarator272 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MUL_in_pointer283 = new BitSet(new long[]{0xFC00000001001002L,0x00000000000017FFL});
    public static final BitSet FOLLOW_type_qualifier_in_pointer285 = new BitSet(new long[]{0x0000000001000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_direct_declarator299 = new BitSet(new long[]{0x00A0000000000002L});
    public static final BitSet FOLLOW_53_in_direct_declarator307 = new BitSet(new long[]{0xFC20000001001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_declarator_in_direct_declarator309 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_direct_declarator311 = new BitSet(new long[]{0x00A0000000000002L});
    public static final BitSet FOLLOW_55_in_direct_declarator329 = new BitSet(new long[]{0x01240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_direct_declarator331 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_56_in_direct_declarator334 = new BitSet(new long[]{0x0080000000000002L});
    public static final BitSet FOLLOW_53_in_direct_declarator346 = new BitSet(new long[]{0xFC40000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_parameter_declaration_list_in_direct_declarator348 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_direct_declarator351 = new BitSet(new long[]{0x0020000000000002L});
    public static final BitSet FOLLOW_parameter_declaration_in_parameter_declaration_list369 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_51_in_parameter_declaration_list372 = new BitSet(new long[]{0xFC00000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_parameter_declaration_in_parameter_declaration_list374 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_51_in_parameter_declaration_list379 = new BitSet(new long[]{0x0200000000000000L});
    public static final BitSet FOLLOW_57_in_parameter_declaration_list381 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_specifiers_in_parameter_declaration393 = new BitSet(new long[]{0xFC20000001001002L,0x00000000000017FFL});
    public static final BitSet FOLLOW_declarator_in_parameter_declaration396 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_specifiers_in_type_name409 = new BitSet(new long[]{0x0020000001000002L});
    public static final BitSet FOLLOW_abstract_declarator_in_type_name411 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_pointer_in_abstract_declarator422 = new BitSet(new long[]{0x0020000001000002L});
    public static final BitSet FOLLOW_direct_abstract_declarator_in_abstract_declarator424 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_direct_abstract_declarator_in_abstract_declarator430 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_53_in_direct_abstract_declarator440 = new BitSet(new long[]{0x0020000001000000L});
    public static final BitSet FOLLOW_abstract_declarator_in_direct_abstract_declarator442 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_direct_abstract_declarator444 = new BitSet(new long[]{0x00A0000000000002L});
    public static final BitSet FOLLOW_55_in_direct_abstract_declarator456 = new BitSet(new long[]{0x01240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_direct_abstract_declarator458 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_56_in_direct_abstract_declarator461 = new BitSet(new long[]{0x0080000000000002L});
    public static final BitSet FOLLOW_53_in_direct_abstract_declarator472 = new BitSet(new long[]{0xFC40000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_parameter_declaration_list_in_direct_abstract_declarator474 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_direct_abstract_declarator477 = new BitSet(new long[]{0x0020000000000002L});
    public static final BitSet FOLLOW_storage_class_specifier_in_specifiers497 = new BitSet(new long[]{0xFC00000000001002L,0x00000000000017FFL});
    public static final BitSet FOLLOW_type_specifier_in_specifiers501 = new BitSet(new long[]{0xFC00000000001002L,0x00000000000017FFL});
    public static final BitSet FOLLOW_type_qualifier_in_specifiers504 = new BitSet(new long[]{0xFC00000000001002L,0x00000000000017FFL});
    public static final BitSet FOLLOW_set_in_storage_class_specifier0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_62_in_type_specifier536 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_type_specifier541 = new BitSet(new long[]{0x0000000000000000L,0x000000000000007EL});
    public static final BitSet FOLLOW_set_in_type_specifier549 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000078L});
    public static final BitSet FOLLOW_set_in_type_specifier556 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_struct_or_union_specifier_in_type_specifier569 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enum_specifier_in_type_specifier574 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_id_in_type_specifier579 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_type_qualifier0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_type_id614 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_struct_or_union_specifier645 = new BitSet(new long[]{0x0000800000001000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_struct_or_union_specifier651 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_struct_or_union_specifier654 = new BitSet(new long[]{0xFC00000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_struct_declaration_list_in_struct_or_union_specifier656 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_struct_or_union_specifier658 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_struct_or_union_specifier663 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_struct_or_union_specifier669 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_struct_declaration_in_struct_declaration_list680 = new BitSet(new long[]{0xFC00000000001002L,0x00000000000017FFL});
    public static final BitSet FOLLOW_specifiers_in_struct_declaration692 = new BitSet(new long[]{0xFC20000001001000L,0x0000000000001FFFL});
    public static final BitSet FOLLOW_struct_declarator_list_in_struct_declaration694 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_struct_declaration696 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_struct_declarator_in_struct_declarator_list707 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_51_in_struct_declarator_list710 = new BitSet(new long[]{0xFC20000001001000L,0x0000000000001FFFL});
    public static final BitSet FOLLOW_struct_declarator_in_struct_declarator_list712 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_declarator_in_struct_declarator733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_75_in_struct_declarator737 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_struct_declarator739 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_declarator_in_struct_declarator745 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_76_in_enum_specifier763 = new BitSet(new long[]{0x0000800000001000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enum_specifier765 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_enum_specifier768 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_enumerator_list_in_enum_specifier770 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_enum_specifier772 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_76_in_enum_specifier777 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enum_specifier779 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumerator_in_enumerator_list790 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_51_in_enumerator_list793 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_enumerator_in_enumerator_list795 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enumerator808 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_enumerator811 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_enumerator813 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignment_expression_in_initializer828 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_47_in_initializer833 = new BitSet(new long[]{0x00258007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_initializer_list_in_initializer835 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_initializer838 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_initializer_in_initializer_list848 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_51_in_initializer_list851 = new BitSet(new long[]{0x00248007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_initializer_in_initializer_list853 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_assignment_expression_in_argument_expression_list869 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_51_in_argument_expression_list872 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_assignment_expression_in_argument_expression_list874 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_assignment_expression_in_expression895 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_lvalue_in_assignment_expression913 = new BitSet(new long[]{0x001000001FFF8000L});
    public static final BitSet FOLLOW_assign_op_in_assignment_expression915 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_assignment_expression_in_assignment_expression917 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditional_expression_in_assignment_expression922 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_lvalue932 = new BitSet(new long[]{0x00200007E1047000L});
    public static final BitSet FOLLOW_prefix_expression_in_lvalue939 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_assign_op948 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_52_in_assign_op979 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logical_or_expression_in_conditional_expression996 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_77_in_conditional_expression998 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_logical_or_expression_in_conditional_expression1000 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_75_in_conditional_expression1002 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_conditional_expression_in_conditional_expression1004 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logical_or_expression_in_conditional_expression1009 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logical_and_expression_in_logical_or_expression1023 = new BitSet(new long[]{0x0000000000010002L});
    public static final BitSet FOLLOW_OR_in_logical_or_expression1027 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_logical_and_expression_in_logical_or_expression1029 = new BitSet(new long[]{0x0000000000010002L});
    public static final BitSet FOLLOW_inclusive_or_expression_in_logical_and_expression1041 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_AND_in_logical_and_expression1044 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_inclusive_or_expression_in_logical_and_expression1046 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_exclusive_or_expression_in_inclusive_or_expression1058 = new BitSet(new long[]{0x0000000000080002L});
    public static final BitSet FOLLOW_BIT_OR_in_inclusive_or_expression1061 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_exclusive_or_expression_in_inclusive_or_expression1063 = new BitSet(new long[]{0x0000000000080002L});
    public static final BitSet FOLLOW_and_expression_in_exclusive_or_expression1075 = new BitSet(new long[]{0x0000000000200002L});
    public static final BitSet FOLLOW_BIT_XOR_in_exclusive_or_expression1078 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_and_expression_in_exclusive_or_expression1080 = new BitSet(new long[]{0x0000000000200002L});
    public static final BitSet FOLLOW_equality_expression_in_and_expression1092 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_BIT_AND_in_and_expression1095 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_equality_expression_in_and_expression1097 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_relational_expression_in_equality_expression1109 = new BitSet(new long[]{0x0000000000000002L,0x000000000000C000L});
    public static final BitSet FOLLOW_set_in_equality_expression1112 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_relational_expression_in_equality_expression1118 = new BitSet(new long[]{0x0000000000000002L,0x000000000000C000L});
    public static final BitSet FOLLOW_shift_expression_in_relational_expression1130 = new BitSet(new long[]{0x0000000000000002L,0x00000000000F0000L});
    public static final BitSet FOLLOW_set_in_relational_expression1133 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_shift_expression_in_relational_expression1143 = new BitSet(new long[]{0x0000000000000002L,0x00000000000F0000L});
    public static final BitSet FOLLOW_additive_expression_in_shift_expression1155 = new BitSet(new long[]{0x0000000000C00002L});
    public static final BitSet FOLLOW_set_in_shift_expression1158 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_additive_expression_in_shift_expression1164 = new BitSet(new long[]{0x0000000000C00002L});
    public static final BitSet FOLLOW_multiplicative_expression_in_additive_expression1177 = new BitSet(new long[]{0x0000000018000002L});
    public static final BitSet FOLLOW_set_in_additive_expression1181 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_multiplicative_expression_in_additive_expression1187 = new BitSet(new long[]{0x0000000018000002L});
    public static final BitSet FOLLOW_cast_expression_in_multiplicative_expression1200 = new BitSet(new long[]{0x0000000007000002L});
    public static final BitSet FOLLOW_set_in_multiplicative_expression1204 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_cast_expression_in_multiplicative_expression1212 = new BitSet(new long[]{0x0000000007000002L});
    public static final BitSet FOLLOW_53_in_cast_expression1231 = new BitSet(new long[]{0xFC00000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_type_name_in_cast_expression1233 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_cast_expression1235 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_cast_expression_in_cast_expression1237 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unary_expression_in_cast_expression1242 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_prefix_expression_in_unary_expression1252 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_unary_expression1257 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_cast_expression_in_unary_expression1263 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unary_operator_in_unary_expression1268 = new BitSet(new long[]{0x00200007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_cast_expression_in_unary_expression1270 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_84_in_unary_expression1275 = new BitSet(new long[]{0x00200007E1047000L});
    public static final BitSet FOLLOW_prefix_expression_in_unary_expression1277 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_84_in_unary_expression1291 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_unary_expression1293 = new BitSet(new long[]{0xFC00000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_type_name_in_unary_expression1295 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_unary_expression1297 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_unary_operator0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BIT_AND_in_prefix_expression1329 = new BitSet(new long[]{0x00200007E1047000L});
    public static final BitSet FOLLOW_postfix_expression_in_prefix_expression1331 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MUL_in_prefix_expression1336 = new BitSet(new long[]{0x00200007E1047000L});
    public static final BitSet FOLLOW_postfix_expression_in_prefix_expression1338 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_postfix_expression_in_prefix_expression1343 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_expression_in_postfix_expression1356 = new BitSet(new long[]{0x00A0000000006002L,0x0000000000600000L});
    public static final BitSet FOLLOW_55_in_postfix_expression1370 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_postfix_expression1372 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_56_in_postfix_expression1374 = new BitSet(new long[]{0x00A0000000006002L,0x0000000000600000L});
    public static final BitSet FOLLOW_53_in_postfix_expression1382 = new BitSet(new long[]{0x00640007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_argument_expression_list_in_postfix_expression1384 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_postfix_expression1387 = new BitSet(new long[]{0x00A0000000006002L,0x0000000000600000L});
    public static final BitSet FOLLOW_85_in_postfix_expression1395 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_postfix_expression1397 = new BitSet(new long[]{0x00A0000000006002L,0x0000000000600000L});
    public static final BitSet FOLLOW_86_in_postfix_expression1405 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_postfix_expression1407 = new BitSet(new long[]{0x00A0000000006002L,0x0000000000600000L});
    public static final BitSet FOLLOW_INC_in_postfix_expression1415 = new BitSet(new long[]{0x00A0000000006002L,0x0000000000600000L});
    public static final BitSet FOLLOW_DEC_in_postfix_expression1417 = new BitSet(new long[]{0x00A0000000006002L,0x0000000000600000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_primary_expression1439 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constant_in_primary_expression1444 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_53_in_primary_expression1449 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_primary_expression1451 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_primary_expression1453 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_constant0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_labeled_statement_in_statement1530 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_compound_statement_in_statement1535 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_statement_in_statement1540 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_selection_statement_in_statement1545 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_iteration_statement_in_statement1550 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_jump_statement_in_statement1555 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_labeled_statement1566 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_75_in_labeled_statement1568 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_labeled_statement1570 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_87_in_labeled_statement1575 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_labeled_statement1577 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_75_in_labeled_statement1579 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_labeled_statement1581 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_88_in_labeled_statement1586 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_75_in_labeled_statement1588 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_labeled_statement1590 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_47_in_compound_statement1610 = new BitSet(new long[]{0xFC278007F9167000L,0x00000007FB9017FFL});
    public static final BitSet FOLLOW_declaration_in_compound_statement1612 = new BitSet(new long[]{0xFC278007F9167000L,0x00000007FB9017FFL});
    public static final BitSet FOLLOW_statement_list_in_compound_statement1615 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_compound_statement1618 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_statement_list1629 = new BitSet(new long[]{0x00248007F9167002L,0x00000007FB900000L});
    public static final BitSet FOLLOW_50_in_expression_statement1641 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_expression_statement1646 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_expression_statement1648 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_89_in_selection_statement1667 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_selection_statement1669 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_selection_statement1671 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_selection_statement1673 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_selection_statement1675 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L});
    public static final BitSet FOLLOW_90_in_selection_statement1678 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_selection_statement1680 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_89_in_selection_statement1686 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_selection_statement1688 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_selection_statement1690 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_selection_statement1692 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_selection_statement1694 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_91_in_selection_statement1699 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_selection_statement1701 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_selection_statement1703 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_selection_statement1705 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_selection_statement1707 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_92_in_iteration_statement1718 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_iteration_statement1720 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_iteration_statement1722 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_iteration_statement1724 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_iteration_statement1726 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_93_in_iteration_statement1731 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_iteration_statement1733 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
    public static final BitSet FOLLOW_92_in_iteration_statement1735 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_iteration_statement1737 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_iteration_statement1739 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_iteration_statement1741 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_iteration_statement1743 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_94_in_iteration_statement1748 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_iteration_statement1750 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_iteration_statement1752 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_iteration_statement1754 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_iteration_statement1756 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_iteration_statement1758 = new BitSet(new long[]{0x00640007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_iteration_statement1760 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_iteration_statement1763 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_iteration_statement1765 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_95_in_jump_statement1776 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_jump_statement1778 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_jump_statement1780 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_96_in_jump_statement1785 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_jump_statement1787 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_97_in_jump_statement1792 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_jump_statement1794 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_98_in_jump_statement1799 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_jump_statement1801 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_98_in_jump_statement1806 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_jump_statement1808 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_jump_statement1810 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_specifiers_in_synpred1_C135 = new BitSet(new long[]{0xFC20000001001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_pointer_in_synpred1_C138 = new BitSet(new long[]{0xFC20000001001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_direct_declarator_in_synpred1_C141 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_synpred1_C143 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_declarator_in_synpred2_C726 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_75_in_synpred2_C729 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_lvalue_in_synpred3_C907 = new BitSet(new long[]{0x001000001FFF8000L});
    public static final BitSet FOLLOW_assign_op_in_synpred3_C909 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logical_or_expression_in_synpred4_C990 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_77_in_synpred4_C992 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_53_in_synpred5_C1225 = new BitSet(new long[]{0xFC00000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_specifiers_in_synpred5_C1227 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_84_in_synpred6_C1283 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_synpred6_C1285 = new BitSet(new long[]{0xFC00000000001000L,0x00000000000017FFL});
    public static final BitSet FOLLOW_specifiers_in_synpred6_C1287 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_89_in_synpred7_C1667 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_synpred7_C1669 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_synpred7_C1671 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_synpred7_C1673 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_synpred7_C1675 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L});
    public static final BitSet FOLLOW_90_in_synpred7_C1678 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_synpred7_C1680 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_89_in_synpred8_C1686 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_synpred8_C1688 = new BitSet(new long[]{0x00240007F9167000L,0x0000000000100000L});
    public static final BitSet FOLLOW_expression_in_synpred8_C1690 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_synpred8_C1692 = new BitSet(new long[]{0x00248007F9167000L,0x00000007FB900000L});
    public static final BitSet FOLLOW_statement_in_synpred8_C1694 = new BitSet(new long[]{0x0000000000000002L});

}